FEATURE:: Support for metrics collection - Prometheus and Open Telemetry (#3420)

* adding support for prometheus and grafana * open telemetry * lint fixes * missing counter and telemetry standardization --------- Co-authored-by: Henry <hzj94@hotmail.com>
2026-06-28 15:00:57 +03:00 · 2024-11-08 05:30:43 +05:30
parent 8466e1a0b0
commit fe03683f0c
22 changed files with 3493 additions and 54 deletions
@@ -0,0 +1,25 @@
+export interface IMetricsProvider {
+    getName(): string
+    initializeCounters(): void
+    setupMetricsEndpoint(): void
+    incrementCounter(counter: FLOWISE_METRIC_COUNTERS, payload: any): void
+}
+
+export enum FLOWISE_COUNTER_STATUS {
+    SUCCESS = 'success',
+    FAILURE = 'failure'
+}
+
+export enum FLOWISE_METRIC_COUNTERS {
+    CHATFLOW_CREATED = 'chatflow_created',
+    AGENTFLOW_CREATED = 'agentflow_created',
+    ASSISTANT_CREATED = 'assistant_created',
+    TOOL_CREATED = 'tool_created',
+    VECTORSTORE_UPSERT = 'vector_upserted',
+
+    CHATFLOW_PREDICTION_INTERNAL = 'chatflow_prediction_internal',
+    CHATFLOW_PREDICTION_EXTERNAL = 'chatflow_prediction_external',
+
+    AGENTFLOW_PREDICTION_INTERNAL = 'agentflow_prediction_internal',
+    AGENTFLOW_PREDICTION_EXTERNAL = 'agentflow_prediction_external'
+}
@@ -22,6 +22,9 @@ import flowiseApiV1Router from './routes'
 import errorHandlerMiddleware from './middlewares/errors'
 import { SSEStreamer } from './utils/SSEStreamer'
 import { validateAPIKey } from './utils/validateKey'
+import { IMetricsProvider } from './Interface.Metrics'
+import { Prometheus } from './metrics/Prometheus'
+import { OpenTelemetry } from './metrics/OpenTelemetry'
 import 'global-agent/bootstrap'

 declare global {
@@ -40,6 +43,7 @@ export class App {
    telemetry: Telemetry
    AppDataSource: DataSource = getDataSource()
    sseStreamer: SSEStreamer
+    metricsProvider: IMetricsProvider

    constructor() {
        this.app = express()
@@ -138,7 +142,8 @@ export class App {
            '/api/v1/ip',
            '/api/v1/ping',
            '/api/v1/version',
-            '/api/v1/attachments'
+            '/api/v1/attachments',
+            '/api/v1/metrics'
        ]
        const URL_CASE_INSENSITIVE_REGEX: RegExp = /\/api\/v1\//i
        const URL_CASE_SENSITIVE_REGEX: RegExp = /\/api\/v1\//
@@ -204,6 +209,28 @@ export class App {
            })
        }

+        if (process.env.ENABLE_METRICS === 'true') {
+            switch (process.env.METRICS_PROVIDER) {
+                // default to prometheus
+                case 'prometheus':
+                case undefined:
+                    this.metricsProvider = new Prometheus(this.app)
+                    break
+                case 'open_telemetry':
+                    this.metricsProvider = new OpenTelemetry(this.app)
+                    break
+                // add more cases for other metrics providers here
+            }
+            if (this.metricsProvider) {
+                await this.metricsProvider.initializeCounters()
+                logger.info(`📊 [server]: Metrics Provider [${this.metricsProvider.getName()}] has been initialized!`)
+            } else {
+                logger.error(
+                    "❌ [server]: Metrics collection is enabled, but failed to initialize provider (valid values are 'prometheus' or 'open_telemetry'."
+                )
+            }
+        }
+
        this.app.use('/api/v1', flowiseApiV1Router)
        this.sseStreamer = new SSEStreamer(this.app)

@@ -0,0 +1,157 @@
+import { FLOWISE_METRIC_COUNTERS, IMetricsProvider } from '../Interface.Metrics'
+import { Resource } from '@opentelemetry/resources'
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } from '@opentelemetry/semantic-conventions'
+import { MeterProvider, PeriodicExportingMetricReader, Histogram } from '@opentelemetry/sdk-metrics'
+import { diag, DiagLogLevel, DiagConsoleLogger, Attributes, Counter } from '@opentelemetry/api'
+import { getVersion } from 'flowise-components'
+import express from 'express'
+
+export class OpenTelemetry implements IMetricsProvider {
+    private app: express.Application
+    private resource: Resource
+    private otlpMetricExporter: any
+    // private otlpTraceExporter: any
+    // private tracerProvider: NodeTracerProvider
+    private metricReader: PeriodicExportingMetricReader
+    private meterProvider: MeterProvider
+
+    // Map to hold all counters and histograms
+    private counters = new Map<string, Counter | Histogram>()
+    private httpRequestCounter: Counter
+    private httpRequestDuration: any
+
+    constructor(app: express.Application) {
+        this.app = app
+
+        if (!process.env.METRICS_OPEN_TELEMETRY_METRIC_ENDPOINT) {
+            throw new Error('METRICS_OPEN_TELEMETRY_METRIC_ENDPOINT is not defined')
+        }
+
+        if (process.env.METRICS_OPEN_TELEMETRY_DEBUG === 'true') {
+            diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG)
+        }
+    }
+
+    public getName(): string {
+        return 'OpenTelemetry'
+    }
+
+    async initializeCounters(): Promise<void> {
+        // Define the resource with the service name for trace grouping
+        const flowiseVersion = await getVersion()
+
+        this.resource = new Resource({
+            [ATTR_SERVICE_NAME]: process.env.METRICS_SERVICE_NAME || 'FlowiseAI',
+            [ATTR_SERVICE_VERSION]: flowiseVersion.version // Version as a label
+        })
+
+        const metricProtocol = process.env.METRICS_OPEN_TELEMETRY_PROTOCOL || 'http' // Default to 'http'
+        // Conditionally import the correct OTLP exporters based on protocol
+        let OTLPMetricExporter
+        if (metricProtocol === 'http') {
+            OTLPMetricExporter = require('@opentelemetry/exporter-metrics-otlp-http').OTLPMetricExporter
+        } else if (metricProtocol === 'grpc') {
+            OTLPMetricExporter = require('@opentelemetry/exporter-metrics-otlp-grpc').OTLPMetricExporter
+        } else if (metricProtocol === 'proto') {
+            OTLPMetricExporter = require('@opentelemetry/exporter-metrics-otlp-proto').OTLPMetricExporter
+        } else {
+            console.error('Invalid METRICS_OPEN_TELEMETRY_PROTOCOL specified. Please set it to "http", "grpc", or "proto".')
+            process.exit(1) // Exit if invalid protocol type is specified
+        }
+
+        this.otlpMetricExporter = new OTLPMetricExporter({
+            url: process.env.METRICS_OPEN_TELEMETRY_METRIC_ENDPOINT // OTLP endpoint for metrics
+        })
+
+        this.metricReader = new PeriodicExportingMetricReader({
+            exporter: this.otlpMetricExporter,
+            exportIntervalMillis: 5000 // Export metrics every 5 seconds
+        })
+        this.meterProvider = new MeterProvider({ resource: this.resource, readers: [this.metricReader] })
+
+        const meter = this.meterProvider.getMeter('flowise-metrics')
+        // look at the FLOWISE_COUNTER enum in Interface.Metrics.ts and get all values
+        // for each counter in the enum, create a new promClient.Counter and add it to the registry
+        const enumEntries = Object.entries(FLOWISE_METRIC_COUNTERS)
+        enumEntries.forEach(([name, value]) => {
+            // derive proper counter name from the enum value (chatflow_created = Chatflow Created)
+            const properCounterName: string = name.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase())
+            this.counters.set(
+                value,
+                meter.createCounter(value, {
+                    description: properCounterName
+                })
+            )
+        })
+
+        // in addition to the enum counters, add a few more custom counters
+
+        const versionGuage = meter.createGauge('flowise_version', {
+            description: 'Flowise version'
+        })
+        // remove the last dot from the version string, e.g. 2.1.3 -> 2.13 (guage needs a number - float)
+        const formattedVersion = flowiseVersion.version.replace(/\.(\d+)$/, '$1')
+        versionGuage.record(parseFloat(formattedVersion))
+
+        // Counter for HTTP requests with method, path, and status as labels
+        this.httpRequestCounter = meter.createCounter('http_requests_total', {
+            description: 'Counts the number of HTTP requests received'
+        })
+
+        // Histogram to measure HTTP request duration in milliseconds
+        this.httpRequestDuration = meter.createHistogram('http_request_duration_ms', {
+            description: 'Records the duration of HTTP requests in ms'
+        })
+    }
+
+    // Function to record HTTP request duration
+    private recordHttpRequestDuration(durationMs: number, method: string, path: string, status: number) {
+        this.httpRequestDuration.record(durationMs, {
+            method,
+            path,
+            status: status.toString()
+        })
+    }
+
+    // Function to record HTTP requests with specific labels
+    private recordHttpRequest(method: string, path: string, status: number) {
+        this.httpRequestCounter.add(1, {
+            method,
+            path,
+            status: status.toString()
+        })
+    }
+
+    async setupMetricsEndpoint(): Promise<void> {
+        // Graceful shutdown for telemetry data flushing
+        process.on('SIGTERM', async () => {
+            await this.metricReader.shutdown()
+            await this.meterProvider.shutdown()
+        })
+
+        // Runs before each requests
+        this.app.use((req, res, next) => {
+            res.locals.startEpoch = Date.now()
+            next()
+        })
+
+        // Runs after each requests
+        this.app.use((req, res, next) => {
+            res.on('finish', async () => {
+                if (res.locals.startEpoch) {
+                    const responseTimeInMs = Date.now() - res.locals.startEpoch
+                    this.recordHttpRequest(req.method, req.path, res.statusCode)
+                    this.recordHttpRequestDuration(responseTimeInMs, req.method, req.path, res.statusCode)
+                }
+            })
+            next()
+        })
+    }
+
+    async incrementCounter(counter: string, payload: any): Promise<void> {
+        // Increment OpenTelemetry counter with the payload
+        if (this.counters.has(counter)) {
+            ;(this.counters.get(counter) as Counter<Attributes>).add(1, payload)
+        }
+    }
+}
@@ -0,0 +1,122 @@
+import { FLOWISE_METRIC_COUNTERS, IMetricsProvider } from '../Interface.Metrics'
+import express from 'express'
+import promClient, { Counter, Histogram, Registry } from 'prom-client'
+import { getVersion } from 'flowise-components'
+
+export class Prometheus implements IMetricsProvider {
+    private app: express.Application
+    private readonly register: Registry
+    private counters: Map<string, promClient.Counter<string> | promClient.Gauge<string> | promClient.Histogram<string>>
+    private requestCounter: Counter<string>
+    private httpRequestDurationMicroseconds: Histogram<string>
+
+    constructor(app: express.Application) {
+        this.app = app
+        this.register = new promClient.Registry()
+    }
+
+    public getName(): string {
+        return 'Prometheus'
+    }
+
+    async initializeCounters(): Promise<void> {
+        const serviceName: string = process.env.METRICS_SERVICE_NAME || 'FlowiseAI'
+        this.register.setDefaultLabels({
+            app: serviceName
+        })
+
+        // look at the FLOWISE_COUNTER enum in Interface.Metrics.ts and get all values
+        // for each counter in the enum, create a new promClient.Counter and add it to the registry
+        this.counters = new Map<string, promClient.Counter<string>>()
+        const enumEntries = Object.entries(FLOWISE_METRIC_COUNTERS)
+        enumEntries.forEach(([name, value]) => {
+            // derive proper counter name from the enum value (chatflow_created = Chatflow Created)
+            const properCounterName: string = name.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase())
+            this.counters.set(
+                value,
+                new promClient.Counter({
+                    name: value,
+                    help: `Total number of ${properCounterName}`,
+                    labelNames: ['status']
+                })
+            )
+        })
+
+        // in addition to the enum counters, add a few more custom counters
+        // version, http_request_duration_ms, http_requests_total
+        const versionGaugeCounter = new promClient.Gauge({
+            name: 'flowise_version_info',
+            help: 'Flowise version info.',
+            labelNames: ['version']
+        })
+
+        const { version } = await getVersion()
+        versionGaugeCounter.set({ version: 'v' + version }, 1)
+        this.counters.set('flowise_version', versionGaugeCounter)
+
+        this.httpRequestDurationMicroseconds = new promClient.Histogram({
+            name: 'http_request_duration_ms',
+            help: 'Duration of HTTP requests in ms',
+            labelNames: ['method', 'route', 'code'],
+            buckets: [1, 5, 15, 50, 100, 200, 300, 400, 500] // buckets for response time from 0.1ms to 500ms
+        })
+        this.counters.set('http_request_duration_ms', this.httpRequestDurationMicroseconds)
+
+        this.requestCounter = new Counter({
+            name: 'http_requests_total',
+            help: 'Total number of HTTP requests',
+            labelNames: ['method', 'path', 'status']
+        })
+        this.counters.set('http_requests_total', this.requestCounter)
+
+        this.registerMetrics()
+        await this.setupMetricsEndpoint()
+    }
+
+    async setupMetricsEndpoint() {
+        // Add Prometheus middleware to the app
+        this.app.use('/api/v1/metrics', async (req, res) => {
+            res.set('Content-Type', this.register.contentType)
+            const currentMetrics = await this.register.metrics()
+            res.send(currentMetrics).end()
+        })
+
+        // Runs before each requests
+        this.app.use((req, res, next) => {
+            res.locals.startEpoch = Date.now()
+            next()
+        })
+
+        // Runs after each requests
+        this.app.use((req, res, next) => {
+            res.on('finish', async () => {
+                if (res.locals.startEpoch) {
+                    this.requestCounter.inc()
+                    const responseTimeInMs = Date.now() - res.locals.startEpoch
+                    this.httpRequestDurationMicroseconds
+                        .labels(req.method, req.baseUrl, res.statusCode.toString())
+                        .observe(responseTimeInMs)
+                }
+            })
+            next()
+        })
+    }
+
+    public incrementCounter(counter: FLOWISE_METRIC_COUNTERS, payload: any) {
+        // increment the counter with the payload
+        if (this.counters.has(counter)) {
+            ;(this.counters.get(counter) as Counter<string>).labels(payload).inc()
+        }
+    }
+
+    private registerMetrics() {
+        if (process.env.METRICS_INCLUDE_NODE_METRICS !== 'false') {
+            // enable default metrics like CPU usage, memory usage, etc.
+            promClient.collectDefaultMetrics({ register: this.register })
+        }
+        // Add our custom metrics to the registry
+        for (const counter of this.counters.values()) {
+            this.register.registerMetric(counter)
+        }
+    }
+}
@@ -8,6 +8,7 @@ import { decryptCredentialData, getAppVersion } from '../../utils'
 import { InternalFlowiseError } from '../../errors/internalFlowiseError'
 import { getErrorMessage } from '../../errors/utils'
 import { DeleteResult } from 'typeorm'
+import { FLOWISE_METRIC_COUNTERS, FLOWISE_COUNTER_STATUS } from '../../Interface.Metrics'

 const createAssistant = async (requestBody: any): Promise<Assistant> => {
    try {
@@ -111,6 +112,7 @@ const createAssistant = async (requestBody: any): Promise<Assistant> => {
            version: await getAppVersion(),
            assistantId: dbResponse.id
        })
+        appServer.metricsProvider.incrementCounter(FLOWISE_METRIC_COUNTERS.ASSISTANT_CREATED, { status: FLOWISE_COUNTER_STATUS.SUCCESS })
        return dbResponse
    } catch (error) {
        throw new InternalFlowiseError(
@@ -13,6 +13,7 @@ import { containsBase64File, updateFlowDataWithFilePaths } from '../../utils/fil
 import { getRunningExpressApp } from '../../utils/getRunningExpressApp'
 import { utilGetUploadsConfig } from '../../utils/getUploadsConfig'
 import logger from '../../utils/logger'
+import { FLOWISE_METRIC_COUNTERS, FLOWISE_COUNTER_STATUS } from '../../Interface.Metrics'

 // Check if chatflow valid for streaming
 const checkIfChatflowIsValidForStreaming = async (chatflowId: string): Promise<any> => {
@@ -191,6 +192,11 @@ const saveChatflow = async (newChatFlow: ChatFlow): Promise<any> => {
            chatflowId: dbResponse.id,
            flowGraph: getTelemetryFlowObj(JSON.parse(dbResponse.flowData)?.nodes, JSON.parse(dbResponse.flowData)?.edges)
        })
+        appServer.metricsProvider.incrementCounter(
+            dbResponse?.type === 'MULTIAGENT' ? FLOWISE_METRIC_COUNTERS.AGENTFLOW_CREATED : FLOWISE_METRIC_COUNTERS.CHATFLOW_CREATED,
+            { status: FLOWISE_COUNTER_STATUS.SUCCESS }
+        )
+
        return dbResponse
    } catch (error) {
        throw new InternalFlowiseError(
@@ -31,7 +31,7 @@ import { Document } from '@langchain/core/documents'
 import { App } from '../../index'
 import { UpsertHistory } from '../../database/entities/UpsertHistory'
 import { cloneDeep, omit } from 'lodash'
-import telemetryService from '../telemetry'
+import { FLOWISE_COUNTER_STATUS, FLOWISE_METRIC_COUNTERS } from '../../Interface.Metrics'

 const DOCUMENT_STORE_BASE_FOLDER = 'docustore'

@@ -990,15 +990,13 @@ const _insertIntoVectorStoreWorkerThread = async (data: ICommonObject) => {
            await appServer.AppDataSource.getRepository(UpsertHistory).save(upsertHistoryItem)
        }

-        await telemetryService.createEvent({
-            name: `vector_upserted`,
-            data: {
-                version: await getAppVersion(),
-                chatlowId: chatflowid,
-                type: ChatType.INTERNAL,
-                flowGraph: omit(indexResult['result'], ['totalKeys', 'addedDocs'])
-            }
+        await appServer.telemetry.sendTelemetry('vector_upserted', {
+            version: await getAppVersion(),
+            chatlowId: chatflowid,
+            type: ChatType.INTERNAL,
+            flowGraph: omit(indexResult['result'], ['totalKeys', 'addedDocs'])
        })
+        appServer.metricsProvider.incrementCounter(FLOWISE_METRIC_COUNTERS.VECTORSTORE_UPSERT, { status: FLOWISE_COUNTER_STATUS.SUCCESS })

        entity.status = DocumentStoreStatus.UPSERTED
        await appServer.AppDataSource.getRepository(DocumentStore).save(entity)
@@ -1,10 +0,0 @@
-import { getRunningExpressApp } from '../../utils/getRunningExpressApp'
-
-const createEvent = async (eventInfo: any) => {
-    const appServer = getRunningExpressApp()
-    await appServer.telemetry.sendTelemetry(eventInfo.name, eventInfo.data)
-}
-
-export default {
-    createEvent
-}
@@ -4,6 +4,7 @@ import { InternalFlowiseError } from '../../errors/internalFlowiseError'
 import { getErrorMessage } from '../../errors/utils'
 import { getAppVersion } from '../../utils'
 import { getRunningExpressApp } from '../../utils/getRunningExpressApp'
+import { FLOWISE_METRIC_COUNTERS, FLOWISE_COUNTER_STATUS } from '../../Interface.Metrics'

 const createTool = async (requestBody: any): Promise<any> => {
    try {
@@ -17,6 +18,7 @@ const createTool = async (requestBody: any): Promise<any> => {
            toolId: dbResponse.id,
            toolName: dbResponse.name
        })
+        appServer.metricsProvider.incrementCounter(FLOWISE_METRIC_COUNTERS.TOOL_CREATED, { status: FLOWISE_COUNTER_STATUS.SUCCESS })
        return dbResponse
    } catch (error) {
        throw new InternalFlowiseError(StatusCodes.INTERNAL_SERVER_ERROR, `Error: toolsService.createTool - ${getErrorMessage(error)}`)
@@ -55,6 +55,7 @@ import { buildAgentGraph } from './buildAgentGraph'
 import { getErrorMessage } from '../errors/utils'
 import { ChatMessage } from '../database/entities/ChatMessage'
 import { IAction } from 'flowise-components'
+import { FLOWISE_METRIC_COUNTERS, FLOWISE_COUNTER_STATUS } from '../Interface.Metrics'

 /**
 * Build Chatflow
@@ -62,8 +63,8 @@ import { IAction } from 'flowise-components'
 * @param {boolean} isInternal
 */
 export const utilBuildChatflow = async (req: Request, isInternal: boolean = false): Promise<any> => {
+    const appServer = getRunningExpressApp()
    try {
-        const appServer = getRunningExpressApp()
        const chatflowid = req.params.id

        const httpProtocol = req.get('x-forwarded-proto') || req.protocol
@@ -493,6 +494,10 @@ export const utilBuildChatflow = async (req: Request, isInternal: boolean = fals
            flowGraph: getTelemetryFlowObj(nodes, edges)
        })

+        appServer.metricsProvider.incrementCounter(
+            isInternal ? FLOWISE_METRIC_COUNTERS.CHATFLOW_PREDICTION_INTERNAL : FLOWISE_METRIC_COUNTERS.CHATFLOW_PREDICTION_EXTERNAL,
+            { status: FLOWISE_COUNTER_STATUS.SUCCESS }
+        )
        // Prepare response
        // return the question in the response
        // this is used when input text is empty but question is in audio format
@@ -507,6 +512,10 @@ export const utilBuildChatflow = async (req: Request, isInternal: boolean = fals

        return result
    } catch (e) {
+        appServer.metricsProvider.incrementCounter(
+            isInternal ? FLOWISE_METRIC_COUNTERS.CHATFLOW_PREDICTION_INTERNAL : FLOWISE_METRIC_COUNTERS.CHATFLOW_PREDICTION_EXTERNAL,
+            { status: FLOWISE_COUNTER_STATUS.FAILURE }
+        )
        logger.error('[server]: Error:', e)
        if (e instanceof InternalFlowiseError && e.statusCode === StatusCodes.UNAUTHORIZED) {
            throw e
@@ -533,8 +542,8 @@ const utilBuildAgentResponse = async (
    shouldStreamResponse?: boolean,
    uploadedFilesContent?: string
 ) => {
+    const appServer = getRunningExpressApp()
    try {
-        const appServer = getRunningExpressApp()
        const streamResults = await buildAgentGraph(
            agentflow,
            chatId,
@@ -599,6 +608,10 @@ const utilBuildAgentResponse = async (
                type: isInternal ? ChatType.INTERNAL : ChatType.EXTERNAL,
                flowGraph: getTelemetryFlowObj(nodes, edges)
            })
+            appServer.metricsProvider.incrementCounter(
+                isInternal ? FLOWISE_METRIC_COUNTERS.AGENTFLOW_PREDICTION_INTERNAL : FLOWISE_METRIC_COUNTERS.AGENTFLOW_PREDICTION_EXTERNAL,
+                { status: FLOWISE_COUNTER_STATUS.SUCCESS }
+            )

            // Find the previous chat message with the same action id and remove the action
            if (incomingInput.action && Object.keys(incomingInput.action).length) {
@@ -645,6 +658,10 @@ const utilBuildAgentResponse = async (
        return undefined
    } catch (e) {
        logger.error('[server]: Error:', e)
+        appServer.metricsProvider.incrementCounter(
+            isInternal ? FLOWISE_METRIC_COUNTERS.AGENTFLOW_PREDICTION_INTERNAL : FLOWISE_METRIC_COUNTERS.AGENTFLOW_PREDICTION_EXTERNAL,
+            { status: FLOWISE_COUNTER_STATUS.FAILURE }
+        )
        throw new InternalFlowiseError(StatusCodes.INTERNAL_SERVER_ERROR, getErrorMessage(e))
    }
 }
@@ -3,7 +3,6 @@ import * as fs from 'fs'
 import * as path from 'path'
 import { cloneDeep, omit } from 'lodash'
 import { ICommonObject, IMessage, addArrayFilesToStorage, mapMimeTypeToInputField, mapExtToInputField } from 'flowise-components'
-import telemetryService from '../services/telemetry'
 import logger from '../utils/logger'
 import {
    buildFlow,
@@ -24,6 +23,7 @@ import { InternalFlowiseError } from '../errors/internalFlowiseError'
 import { StatusCodes } from 'http-status-codes'
 import { getErrorMessage } from '../errors/utils'
 import { v4 as uuidv4 } from 'uuid'
+import { FLOWISE_COUNTER_STATUS, FLOWISE_METRIC_COUNTERS } from '../Interface.Metrics'
 /**
 * Upsert documents
 * @param {Request} req
@@ -190,16 +190,14 @@ export const upsertVector = async (req: Request, isInternal: boolean = false) =>
            await appServer.AppDataSource.getRepository(UpsertHistory).save(upsertHistory)
        }

-        await telemetryService.createEvent({
-            name: `vector_upserted`,
-            data: {
-                version: await getAppVersion(),
-                chatlowId: chatflowid,
-                type: isInternal ? ChatType.INTERNAL : ChatType.EXTERNAL,
-                flowGraph: getTelemetryFlowObj(nodes, edges),
-                stopNodeId
-            }
+        await appServer.telemetry.sendTelemetry('vector_upserted', {
+            version: await getAppVersion(),
+            chatlowId: chatflowid,
+            type: isInternal ? ChatType.INTERNAL : ChatType.EXTERNAL,
+            flowGraph: getTelemetryFlowObj(nodes, edges),
+            stopNodeId
        })
+        appServer.metricsProvider.incrementCounter(FLOWISE_METRIC_COUNTERS.VECTORSTORE_UPSERT, { status: FLOWISE_COUNTER_STATUS.SUCCESS })

        return upsertedResult['result'] ?? { result: 'Successfully Upserted' }
    } catch (e) {