@microsoft/opentelemetry 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/esm/azureMonitor/metrics/quickpulse/liveMetrics.js

@@ -0,0 +1,709 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import os from "node:os";
+import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { SpanKind, SpanStatusCode, ValueType, context } from "@opentelemetry/api";
+import { RandomIdGenerator } from "@opentelemetry/sdk-trace-base";
+import { getLogDocument, getSdkVersion, getSpanData, getLogData, getSpanDocument, getTransmissionTime, isRequestData, getSpanExceptionColumns, isExceptionData, isDependencyData, } from "./utils.js";
+import { QuickpulseMetricExporter } from "./export/exporter.js";
+import { QuickpulseSender } from "./export/sender.js";
+import { ConnectionStringParser } from "../../utils/connectionStringParser.js";
+import { DEFAULT_LIVEMETRICS_ENDPOINT } from "../../../types.js";
+import { QuickPulseOpenTelemetryMetricNames } from "./types.js";
+import { hrTimeToMilliseconds, suppressTracing } from "@opentelemetry/core";
+import { getInstance } from "../../utils/statsbeat.js";
+import { Filter } from "./filtering/filter.js";
+import { Validator } from "./filtering/validator.js";
+import { CollectionConfigurationErrorTracker } from "./filtering/collectionConfigurationErrorTracker.js";
+import { Projection } from "./filtering/projection.js";
+import { TelemetryTypeError, UnexpectedFilterCreateError, DuplicateMetricIdError, MetricFailureToCreateError, } from "./filtering/quickpulseErrors.js";
+import { SEMATTRS_EXCEPTION_TYPE } from "@opentelemetry/semantic-conventions";
+import { getPhysicalMemory, getProcessorTimeNormalized } from "../utils.js";
+import { getCloudRole, getCloudRoleInstance } from "../utils.js";
+import { Logger } from "../../../shared/logging/logger.js";
+const POST_INTERVAL = 1000;
+const MAX_POST_WAIT_TIME = 20000;
+const PING_INTERVAL = 5000;
+const MAX_PING_WAIT_TIME = 60000;
+const FALLBACK_INTERVAL = 60000;
+/**
+ * Azure Monitor Live Metrics
+ * @internal
+ */
+export class LiveMetrics {
+    config;
+    meterProvider;
+    metricReader;
+    meter;
+    requestDurationGauge;
+    dependencyDurationGauge;
+    requestRateGauge;
+    requestFailedRateGauge;
+    dependencyRateGauge;
+    dependencyFailedRateGauge;
+    processPhysicalBytesGauge;
+    percentProcessorTimeNormalizedGauge;
+    exceptionsRateGauge;
+    documents = [];
+    pingInterval;
+    postInterval;
+    quickpulseExporter;
+    pingSender;
+    isCollectingData;
+    lastSuccessTime = Date.now();
+    handle;
+    // Monitoring data point with common properties
+    baseMonitoringDataPoint;
+    totalRequestCount = 0;
+    totalFailedRequestCount = 0;
+    totalDependencyCount = 0;
+    totalFailedDependencyCount = 0;
+    totalExceptionCount = 0;
+    requestDuration = 0;
+    dependencyDuration = 0;
+    lastRequestDuration = {
+        count: 0,
+        duration: 0,
+        time: 0,
+    };
+    lastRequestRate = { count: 0, time: 0 };
+    lastFailedRequestRate = { count: 0, time: 0 };
+    lastDependencyDuration = {
+        count: 0,
+        duration: 0,
+        time: 0,
+    };
+    lastDependencyRate = { count: 0, time: 0 };
+    lastFailedDependencyRate = { count: 0, time: 0 };
+    lastExceptionRate = { count: 0, time: 0 };
+    lastCpuUsage;
+    lastHrTime;
+    statsbeatOptionsUpdated = false;
+    etag = "";
+    errorTracker = new CollectionConfigurationErrorTracker();
+    // For tracking of duplicate metric ids in the same configuration.
+    seenMetricIds = new Set();
+    validDerivedMetrics = new Map();
+    derivedMetricProjection = new Projection();
+    validator = new Validator();
+    filter = new Filter();
+    // type: Map<telemetryType, Map<id, FilterConjunctionGroupInfo[]>>
+    validDocumentFilterConjuctionGroupInfos = new Map();
+    /**
+     * Initializes a new instance of the StandardMetrics class.
+     * @param config - Distro configuration.
+     * @param options - Standard Metrics options.
+     */
+    constructor(config) {
+        this.config = config;
+        const idGenerator = new RandomIdGenerator();
+        const streamId = idGenerator.generateTraceId();
+        const machineName = os.hostname();
+        const instance = getCloudRoleInstance(this.config.resource);
+        const roleName = getCloudRole(this.config.resource);
+        const version = getSdkVersion();
+        this.baseMonitoringDataPoint = {
+            version: version,
+            invariantVersion: 5, // 5 means we support live metrics filtering of metrics and documents
+            instance: instance,
+            roleName: roleName,
+            machineName: machineName,
+            streamId: streamId,
+            performanceCollectionSupported: true,
+            isWebApp: process.env["WEBSITE_SITE_NAME"] ? true : false,
+        };
+        const parsedConnectionString = ConnectionStringParser.parse(this.config.azureMonitorExporterOptions.connectionString ||
+            process.env["APPLICATIONINSIGHTS_CONNECTION_STRING"]);
+        this.pingSender = new QuickpulseSender({
+            endpointUrl: parsedConnectionString.liveendpoint || DEFAULT_LIVEMETRICS_ENDPOINT,
+            instrumentationKey: parsedConnectionString.instrumentationkey || "",
+            credential: this.config.azureMonitorExporterOptions.credential,
+            credentialScopes: parsedConnectionString.aadaudience ||
+                this.config.azureMonitorExporterOptions.credentialScopes,
+        });
+        const exporterOptions = {
+            endpointUrl: parsedConnectionString.liveendpoint || DEFAULT_LIVEMETRICS_ENDPOINT,
+            instrumentationKey: parsedConnectionString.instrumentationkey || "",
+            credential: this.config.azureMonitorExporterOptions.credential,
+            credentialScopes: parsedConnectionString.aadaudience ||
+                this.config.azureMonitorExporterOptions.credentialScopes,
+            postCallback: this.quickPulseDone.bind(this),
+            getDocumentsFn: this.getDocuments.bind(this),
+            getErrorsFn: this.getErrors.bind(this),
+            getDerivedMetricValuesFn: this.getDerivedMetricValues.bind(this),
+            baseMonitoringDataPoint: this.baseMonitoringDataPoint,
+        };
+        this.quickpulseExporter = new QuickpulseMetricExporter(exporterOptions);
+        this.isCollectingData = false;
+        this.pingInterval = PING_INTERVAL; // Default
+        this.postInterval = POST_INTERVAL;
+        this.handle = setTimeout(this.goQuickpulse.bind(this), this.pingInterval);
+        this.handle.unref(); // Don't block apps from terminating
+        this.lastCpuUsage = process.cpuUsage();
+        this.lastHrTime = process.hrtime.bigint();
+    }
+    shutdown() {
+        this.meterProvider?.shutdown();
+    }
+    async goQuickpulse() {
+        if (!this.isCollectingData) {
+            // If not collecting, Ping
+            try {
+                const params = {
+                    transmissionTime: getTransmissionTime(),
+                    monitoringDataPoint: this.baseMonitoringDataPoint,
+                    configurationEtag: this.etag,
+                };
+                await context.with(suppressTracing(context.active()), async () => {
+                    const response = await this.pingSender.isSubscribed(params);
+                    this.quickPulseDone(response);
+                });
+            }
+            catch (_error) {
+                this.quickPulseDone(undefined);
+            }
+            this.handle = setTimeout(this.goQuickpulse.bind(this), this.pingInterval);
+            this.handle.unref();
+        }
+        if (this.isCollectingData) {
+            this.activateMetrics({ collectionInterval: this.postInterval });
+        }
+    }
+    async quickPulseDone(response) {
+        if (!response) {
+            if (!this.isCollectingData) {
+                if (Date.now() - this.lastSuccessTime >= MAX_PING_WAIT_TIME) {
+                    this.pingInterval = FALLBACK_INTERVAL;
+                }
+            }
+            else {
+                if (Date.now() - this.lastSuccessTime >= MAX_POST_WAIT_TIME) {
+                    this.postInterval = FALLBACK_INTERVAL;
+                    this.deactivateMetrics();
+                    this.activateMetrics({ collectionInterval: this.postInterval });
+                }
+            }
+        }
+        else {
+            this.postInterval = POST_INTERVAL;
+            // Update using response if needed
+            this.lastSuccessTime = Date.now();
+            this.isCollectingData =
+                response.xMsQpsSubscribed && response.xMsQpsSubscribed === "true" ? true : false;
+            if (response.xMsQpsConfigurationEtag && this.etag !== response.xMsQpsConfigurationEtag) {
+                this.updateConfiguration(response);
+            }
+            // If collecting was stoped
+            if (!this.isCollectingData && this.meterProvider) {
+                this.etag = "";
+                this.deactivateMetrics();
+                this.handle = setTimeout(this.goQuickpulse.bind(this), this.pingInterval);
+                this.handle.unref();
+            }
+            const endpointRedirect = response.xMsQpsServiceEndpointRedirectV2;
+            if (endpointRedirect) {
+                this.pingSender.handlePermanentRedirect(endpointRedirect);
+                this.quickpulseExporter.getSender().handlePermanentRedirect(endpointRedirect);
+            }
+            const pollingInterval = response.xMsQpsServicePollingIntervalHint;
+            if (pollingInterval) {
+                this.pingInterval = Number(pollingInterval);
+            }
+            else {
+                this.pingInterval = PING_INTERVAL;
+            }
+        }
+    }
+    // Activate live metrics collection
+    activateMetrics(options) {
+        if (this.meterProvider) {
+            return;
+        }
+        // Turn on live metrics active collection for statsbeat
+        if (!this.statsbeatOptionsUpdated) {
+            getInstance().setStatsbeatFeatures({}, { liveMetrics: true });
+            this.statsbeatOptionsUpdated = true;
+        }
+        this.totalDependencyCount = 0;
+        this.totalExceptionCount = 0;
+        this.totalFailedDependencyCount = 0;
+        this.totalFailedRequestCount = 0;
+        this.totalRequestCount = 0;
+        this.requestDuration = 0;
+        this.dependencyDuration = 0;
+        this.lastRequestDuration = { count: 0, duration: 0, time: 0 };
+        this.lastRequestRate = { count: 0, time: 0 };
+        this.lastFailedRequestRate = { count: 0, time: 0 };
+        this.lastDependencyDuration = { count: 0, duration: 0, time: 0 };
+        this.lastDependencyRate = { count: 0, time: 0 };
+        this.lastFailedDependencyRate = { count: 0, time: 0 };
+        this.lastExceptionRate = { count: 0, time: 0 };
+        const metricReaderOptions = {
+            exporter: this.quickpulseExporter,
+            exportIntervalMillis: options?.collectionInterval,
+        };
+        this.metricReader = new PeriodicExportingMetricReader(metricReaderOptions);
+        const meterProviderConfig = {
+            resource: this.config.resource,
+            readers: [this.metricReader],
+        };
+        this.meterProvider = new MeterProvider(meterProviderConfig);
+        this.meter = this.meterProvider.getMeter("AzureMonitorLiveMetricsMeter");
+        this.requestDurationGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.REQUEST_DURATION, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.requestRateGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.REQUEST_RATE, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.requestFailedRateGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.REQUEST_FAILURE_RATE, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.dependencyDurationGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.DEPENDENCY_DURATION, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.dependencyRateGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.DEPENDENCY_RATE, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.dependencyFailedRateGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.DEPENDENCY_FAILURE_RATE, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.processPhysicalBytesGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.PHYSICAL_BYTES, {
+            valueType: ValueType.INT,
+        });
+        this.percentProcessorTimeNormalizedGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.PROCESSOR_TIME_NORMALIZED, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.exceptionsRateGauge = this.meter.createObservableGauge(QuickPulseOpenTelemetryMetricNames.EXCEPTION_RATE, {
+            valueType: ValueType.DOUBLE,
+        });
+        this.requestDurationGauge.addCallback(this.getRequestDuration.bind(this));
+        this.requestRateGauge.addCallback(this.getRequestRate.bind(this));
+        this.requestFailedRateGauge.addCallback(this.getRequestFailedRate.bind(this));
+        this.dependencyDurationGauge.addCallback(this.getDependencyDuration.bind(this));
+        this.dependencyRateGauge.addCallback(this.getDependencyRate.bind(this));
+        this.dependencyFailedRateGauge.addCallback(this.getDependencyFailedRate.bind(this));
+        this.exceptionsRateGauge.addCallback(this.getExceptionRate.bind(this));
+        this.processPhysicalBytesGauge.addCallback(this.getPhysicalMemory.bind(this));
+        this.percentProcessorTimeNormalizedGauge.addCallback(this.getProcessorTimeNormalized.bind(this));
+    }
+    /**
+     * Deactivate metric collection
+     */
+    deactivateMetrics() {
+        this.documents = [];
+        this.validDocumentFilterConjuctionGroupInfos.clear();
+        this.errorTracker.clearRunTimeErrors();
+        this.errorTracker.clearValidationTimeErrors();
+        this.validDerivedMetrics.clear();
+        this.derivedMetricProjection.clearProjectionMaps();
+        this.seenMetricIds.clear();
+        this.meterProvider?.shutdown();
+        this.meterProvider = undefined;
+    }
+    /**
+     * Force flush Meter Provider.
+     */
+    async flush() {
+        await this.meterProvider?.forceFlush();
+    }
+    /**
+     *Get OpenTelemetry MeterProvider
+     */
+    getMeterProvider() {
+        return this.meterProvider;
+    }
+    getDocuments() {
+        const result = this.documents;
+        this.documents = [];
+        return result;
+    }
+    getErrors() {
+        const result = this.errorTracker.getErrors();
+        this.errorTracker.clearRunTimeErrors();
+        return result;
+    }
+    getDerivedMetricValues() {
+        return this.derivedMetricProjection.getMetricValues();
+    }
+    addDocument(document) {
+        if (document) {
+            // Limit risk of memory leak by limiting doc length to something manageable
+            if (this.documents.length > 20) {
+                this.documents.shift(); // Remove oldest document
+            }
+            this.documents.push(document);
+        }
+    }
+    /**
+     * Record Span metrics
+     * @internal
+     */
+    recordSpan(span) {
+        if (this.isCollectingData) {
+            const columns = getSpanData(span);
+            let documentConfiguration;
+            let derivedMetricInfos;
+            if (isRequestData(columns)) {
+                documentConfiguration =
+                    this.validDocumentFilterConjuctionGroupInfos.get("Request") ||
+                        new Map();
+                derivedMetricInfos = this.validDerivedMetrics.get("Request") || [];
+            }
+            else {
+                documentConfiguration =
+                    this.validDocumentFilterConjuctionGroupInfos.get("Dependency") ||
+                        new Map();
+                derivedMetricInfos = this.validDerivedMetrics.get("Dependency") || [];
+            }
+            this.applyDocumentFilters(documentConfiguration, columns);
+            this.checkMetricFilterAndCreateProjection(derivedMetricInfos, columns);
+            const durationMs = hrTimeToMilliseconds(span.duration);
+            const success = span.status.code !== SpanStatusCode.ERROR;
+            if (span.kind === SpanKind.SERVER || span.kind === SpanKind.CONSUMER) {
+                this.totalRequestCount++;
+                this.requestDuration += durationMs;
+                if (!success) {
+                    this.totalFailedRequestCount++;
+                }
+            }
+            else {
+                this.totalDependencyCount++;
+                this.dependencyDuration += durationMs;
+                if (!success) {
+                    this.totalFailedDependencyCount++;
+                }
+            }
+            if (span.events) {
+                span.events.forEach((event) => {
+                    event.attributes = event.attributes || {};
+                    if (event.name === "exception") {
+                        const exceptionColumns = getSpanExceptionColumns(event.attributes, span.attributes);
+                        documentConfiguration =
+                            this.validDocumentFilterConjuctionGroupInfos.get("Exception") ||
+                                new Map();
+                        this.applyDocumentFilters(documentConfiguration, exceptionColumns, event.attributes[SEMATTRS_EXCEPTION_TYPE]);
+                        derivedMetricInfos = this.validDerivedMetrics.get("Exception") || [];
+                        this.checkMetricFilterAndCreateProjection(derivedMetricInfos, exceptionColumns);
+                        this.totalExceptionCount++;
+                    }
+                });
+            }
+        }
+    }
+    /**
+     * Record LogRecord metrics, add attribute so data is not aggregated again in ingestion
+     * @internal
+     */
+    recordLog(logRecord) {
+        if (this.isCollectingData) {
+            const columns = getLogData(logRecord);
+            let derivedMetricInfos;
+            let documentConfiguration;
+            if (isExceptionData(columns)) {
+                documentConfiguration =
+                    this.validDocumentFilterConjuctionGroupInfos.get("Exception") ||
+                        new Map();
+                this.applyDocumentFilters(documentConfiguration, columns, logRecord.attributes[SEMATTRS_EXCEPTION_TYPE]);
+                derivedMetricInfos = this.validDerivedMetrics.get("Exception") || [];
+                this.totalExceptionCount++;
+            }
+            else {
+                // trace
+                documentConfiguration =
+                    this.validDocumentFilterConjuctionGroupInfos.get("Trace") ||
+                        new Map();
+                this.applyDocumentFilters(documentConfiguration, columns);
+                derivedMetricInfos = this.validDerivedMetrics.get("Trace") || [];
+            }
+            this.checkMetricFilterAndCreateProjection(derivedMetricInfos, columns);
+        }
+    }
+    getRequestDuration(observableResult) {
+        const currentTime = +new Date();
+        const requestInterval = this.totalRequestCount - this.lastRequestDuration.count || 0;
+        const durationInterval = this.requestDuration - this.lastRequestDuration.duration || 0;
+        const elapsedMs = currentTime - this.lastRequestDuration.time;
+        if (elapsedMs > 0) {
+            const averageExecutionTime = durationInterval / requestInterval || 0; // default to 0 in case no requests in this interval
+            observableResult.observe(averageExecutionTime);
+        }
+        this.lastRequestDuration = {
+            count: this.totalRequestCount,
+            duration: this.requestDuration,
+            time: currentTime,
+        };
+    }
+    getRequestRate(observableResult) {
+        const currentTime = +new Date();
+        const intervalRequests = this.totalRequestCount - this.lastRequestRate.count || 0;
+        const elapsedMs = currentTime - this.lastRequestRate.time;
+        if (elapsedMs > 0) {
+            const elapsedSeconds = elapsedMs / 1000;
+            const dataPerSec = intervalRequests / elapsedSeconds;
+            observableResult.observe(dataPerSec);
+        }
+        this.lastRequestRate = {
+            count: this.totalRequestCount,
+            time: currentTime,
+        };
+    }
+    getRequestFailedRate(observableResult) {
+        const currentTime = +new Date();
+        const intervalRequests = this.totalFailedRequestCount - this.lastFailedRequestRate.count || 0;
+        const elapsedMs = currentTime - this.lastFailedRequestRate.time;
+        if (elapsedMs > 0) {
+            const elapsedSeconds = elapsedMs / 1000;
+            const dataPerSec = intervalRequests / elapsedSeconds;
+            observableResult.observe(dataPerSec);
+        }
+        this.lastFailedRequestRate = {
+            count: this.totalFailedRequestCount,
+            time: currentTime,
+        };
+    }
+    getDependencyDuration(observableResult) {
+        const currentTime = +new Date();
+        const dependencyInterval = this.totalDependencyCount - this.lastDependencyDuration.count || 0;
+        const durationInterval = this.dependencyDuration - this.lastDependencyDuration.duration || 0;
+        const elapsedMs = currentTime - this.lastDependencyDuration.time;
+        if (elapsedMs > 0) {
+            const averageExecutionTime = durationInterval / dependencyInterval || 0; // default to 0 in case no dependencies in this interval
+            observableResult.observe(averageExecutionTime);
+        }
+        this.lastDependencyDuration = {
+            count: this.totalDependencyCount,
+            duration: this.dependencyDuration,
+            time: currentTime,
+        };
+    }
+    getDependencyRate(observableResult) {
+        const currentTime = +new Date();
+        const intervalData = this.totalDependencyCount - this.lastDependencyRate.count || 0;
+        const elapsedMs = currentTime - this.lastDependencyRate.time;
+        if (elapsedMs > 0) {
+            const elapsedSeconds = elapsedMs / 1000;
+            const dataPerSec = intervalData / elapsedSeconds;
+            observableResult.observe(dataPerSec);
+        }
+        this.lastDependencyRate = {
+            count: this.totalDependencyCount,
+            time: currentTime,
+        };
+    }
+    getDependencyFailedRate(observableResult) {
+        const currentTime = +new Date();
+        const intervalData = this.totalFailedDependencyCount - this.lastFailedDependencyRate.count || 0;
+        const elapsedMs = currentTime - this.lastFailedDependencyRate.time;
+        if (elapsedMs > 0) {
+            const elapsedSeconds = elapsedMs / 1000;
+            const dataPerSec = intervalData / elapsedSeconds;
+            observableResult.observe(dataPerSec);
+        }
+        this.lastFailedDependencyRate = {
+            count: this.totalFailedDependencyCount,
+            time: currentTime,
+        };
+    }
+    getExceptionRate(observableResult) {
+        const currentTime = +new Date();
+        const intervalData = this.totalExceptionCount - this.lastExceptionRate.count || 0;
+        const elapsedMs = currentTime - this.lastExceptionRate.time;
+        if (elapsedMs > 0) {
+            const elapsedSeconds = elapsedMs / 1000;
+            const dataPerSec = intervalData / elapsedSeconds;
+            observableResult.observe(dataPerSec);
+        }
+        this.lastExceptionRate = {
+            count: this.totalExceptionCount,
+            time: currentTime,
+        };
+    }
+    getPhysicalMemory(observableResult) {
+        const rss = getPhysicalMemory();
+        observableResult.observe(rss);
+    }
+    getProcessorTimeNormalized(observableResult) {
+        if (process && process.hrtime) {
+            const cpuUsagePercent = getProcessorTimeNormalized(this.lastHrTime, this.lastCpuUsage);
+            observableResult.observe(cpuUsagePercent);
+            this.lastHrTime = process.hrtime.bigint();
+            this.lastCpuUsage = process.cpuUsage();
+        }
+        else {
+            Logger.getInstance().debug("Getting Normalized Processor Time Failed. No process available.");
+        }
+    }
+    updateConfiguration(response) {
+        this.etag = response.xMsQpsConfigurationEtag || "";
+        this.quickpulseExporter.setEtag(this.etag);
+        this.errorTracker.clearValidationTimeErrors();
+        this.validDocumentFilterConjuctionGroupInfos.clear();
+        this.validDerivedMetrics.clear();
+        this.derivedMetricProjection.clearProjectionMaps();
+        this.seenMetricIds.clear();
+        this.parseDocumentFilterConfiguration(response);
+        this.parseMetricFilterConfiguration(response);
+    }
+    parseDocumentFilterConfiguration(response) {
+        if (!response?.documentStreams || typeof response.documentStreams.forEach !== "function") {
+            return;
+        }
+        response.documentStreams.forEach((documentStreamInfo) => {
+            documentStreamInfo.documentFilterGroups.forEach((documentFilterGroupInfo) => {
+                try {
+                    this.validator.validateTelemetryType(documentFilterGroupInfo.telemetryType);
+                    this.validator.validateDocumentFilters(documentFilterGroupInfo);
+                    this.filter.renameExceptionFieldNamesForFiltering(documentFilterGroupInfo.filters);
+                    if (!this.validDocumentFilterConjuctionGroupInfos.has(documentFilterGroupInfo.telemetryType)) {
+                        this.validDocumentFilterConjuctionGroupInfos.set(documentFilterGroupInfo.telemetryType, new Map());
+                    }
+                    const innerMap = this.validDocumentFilterConjuctionGroupInfos.get(documentFilterGroupInfo.telemetryType);
+                    if (!innerMap?.has(documentStreamInfo.id)) {
+                        innerMap?.set(documentStreamInfo.id, [documentFilterGroupInfo.filters]);
+                    }
+                    else {
+                        innerMap.get(documentStreamInfo.id)?.push(documentFilterGroupInfo.filters);
+                    }
+                }
+                catch (error) {
+                    const configError = {
+                        collectionConfigurationErrorType: "Unknown",
+                        message: "",
+                        fullException: "",
+                        data: [],
+                    };
+                    if (error instanceof TelemetryTypeError) {
+                        configError.collectionConfigurationErrorType =
+                            "CollectionConfigurationFailureToCreateUnexpected";
+                    }
+                    else if (error instanceof UnexpectedFilterCreateError) {
+                        configError.collectionConfigurationErrorType =
+                            "DocumentStreamFailureToCreateFilterUnexpected";
+                    }
+                    if (error instanceof Error) {
+                        configError.message = error.message;
+                        configError.fullException = error.stack || "";
+                    }
+                    const data = [];
+                    data.push({ key: "DocumentStreamInfoId", value: documentStreamInfo.id });
+                    data.push({ key: "ETag", value: this.etag });
+                    configError.data = data;
+                    this.errorTracker.addValidationError(configError);
+                }
+            });
+        });
+    }
+    applyDocumentFilters(documentConfiguration, data, exceptionType) {
+        const streamIds = new Set();
+        documentConfiguration.forEach((filterConjunctionGroupInfoList, streamId) => {
+            filterConjunctionGroupInfoList.forEach((filterConjunctionGroupInfo) => {
+                // by going though each filterConjuctionGroupInfo, we are implicitly -OR-ing
+                // different filterConjunctionGroupInfo within documentStreamInfo. If there are multiple
+                // documentStreamInfos, this logic will -OR- the filtering results of each documentStreamInfo.
+                if (this.filter.checkFilterConjunctionGroup(filterConjunctionGroupInfo, data)) {
+                    streamIds.add(streamId);
+                }
+            });
+        });
+        // Emit a document when a telemetry data matches a particular filtering configuration,
+        // or when filtering configuration is empty.
+        if (streamIds.size > 0 || documentConfiguration.size === 0) {
+            let document;
+            if (isRequestData(data) || isDependencyData(data)) {
+                document = getSpanDocument(data);
+            }
+            else if (isExceptionData(data) && exceptionType) {
+                document = getLogDocument(data, exceptionType);
+            }
+            else {
+                document = getLogDocument(data);
+            }
+            document.documentStreamIds = [...streamIds];
+            this.addDocument(document);
+        }
+    }
+    parseMetricFilterConfiguration(response) {
+        if (!response?.documentStreams || typeof response.documentStreams.forEach !== "function") {
+            return;
+        }
+        response.metrics.forEach((derivedMetricInfo) => {
+            try {
+                if (!this.seenMetricIds.has(derivedMetricInfo.id)) {
+                    this.seenMetricIds.add(derivedMetricInfo.id);
+                    this.validator.validateTelemetryType(derivedMetricInfo.telemetryType);
+                    this.validator.checkCustomMetricProjection(derivedMetricInfo);
+                    this.validator.validateMetricFilters(derivedMetricInfo);
+                    derivedMetricInfo.filterGroups.forEach((filterConjunctionGroupInfo) => {
+                        this.filter.renameExceptionFieldNamesForFiltering(filterConjunctionGroupInfo);
+                    });
+                    if (this.validDerivedMetrics.has(derivedMetricInfo.telemetryType)) {
+                        this.validDerivedMetrics.get(derivedMetricInfo.telemetryType)?.push(derivedMetricInfo);
+                    }
+                    else {
+                        this.validDerivedMetrics.set(derivedMetricInfo.telemetryType, [derivedMetricInfo]);
+                    }
+                }
+                else {
+                    throw new DuplicateMetricIdError(`Duplicate Metric Id: ${derivedMetricInfo.id}`);
+                }
+                this.derivedMetricProjection.initDerivedMetricProjection(derivedMetricInfo);
+            }
+            catch (error) {
+                const configError = {
+                    collectionConfigurationErrorType: "Unknown",
+                    message: "",
+                    fullException: "",
+                    data: [],
+                };
+                if (error instanceof TelemetryTypeError) {
+                    configError.collectionConfigurationErrorType = "MetricTelemetryTypeUnsupported";
+                }
+                else if (error instanceof UnexpectedFilterCreateError) {
+                    configError.collectionConfigurationErrorType = "MetricFailureToCreateFilterUnexpected";
+                }
+                else if (error instanceof DuplicateMetricIdError) {
+                    configError.collectionConfigurationErrorType = "MetricDuplicateIds";
+                }
+                if (error instanceof Error) {
+                    configError.message = error.message;
+                    configError.fullException = error.stack || "";
+                }
+                const data = [];
+                data.push({ key: "MetricId", value: derivedMetricInfo.id });
+                data.push({ key: "ETag", value: this.etag });
+                configError.data = data;
+                this.errorTracker.addValidationError(configError);
+            }
+        });
+    }
+    checkMetricFilterAndCreateProjection(derivedMetricInfoList, data) {
+        derivedMetricInfoList.forEach((derivedMetricInfo) => {
+            if (this.filter.checkMetricFilters(derivedMetricInfo, data)) {
+                try {
+                    this.derivedMetricProjection.calculateProjection(derivedMetricInfo, data);
+                }
+                catch (error) {
+                    const configError = {
+                        collectionConfigurationErrorType: "Unknown",
+                        message: "",
+                        fullException: "",
+                        data: [],
+                    };
+                    if (error instanceof MetricFailureToCreateError) {
+                        configError.collectionConfigurationErrorType = "MetricFailureToCreate";
+                        if (error instanceof Error) {
+                            configError.message = error.message;
+                            configError.fullException = error.stack || "";
+                        }
+                        const errorData = [];
+                        errorData.push({ key: "MetricId", value: derivedMetricInfo.id });
+                        errorData.push({ key: "ETag", value: this.etag });
+                        configError.data = errorData;
+                        this.errorTracker.addRunTimeError(configError);
+                    }
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=liveMetrics.js.map