Upgrade AppInsights 3.x to use OpenTelemetry JS 2.x Dependencies

.github/workflows/integration.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       matrix:
         # TODO: Enable Node 14.x when we update the pipeline to support AbortController
-        node-version: [16.x]
+        node-version: [18.x]
 
     steps:
     - uses: actions/checkout@v2

package.json

@@ -70,22 +70,22 @@
     "@azure/functions": "^4.6.0",
     "@azure/functions-old": "npm:@azure/functions@3.5.1",
     "@azure/identity": "^4.6.0",
-    "@azure/monitor-opentelemetry": "^1.11.0",
-    "@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.31",
+    "@azure/monitor-opentelemetry": "^1.11.1",
+    "@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.32",
     "@azure/opentelemetry-instrumentation-azure-sdk": "^1.0.0-beta.7",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": "^0.57.2",
-    "@opentelemetry/core": "^1.30.1",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.57.2",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.57.2",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.57.2",
-    "@opentelemetry/otlp-exporter-base": "^0.57.2",
-    "@opentelemetry/resources": "^1.30.1",
-    "@opentelemetry/sdk-logs": "^0.57.2",
-    "@opentelemetry/sdk-metrics": "^1.30.1",
-    "@opentelemetry/sdk-trace-base": "^1.30.1",
-    "@opentelemetry/sdk-trace-node": "^1.30.1",
-    "@opentelemetry/semantic-conventions": "^1.30.0",
+    "@opentelemetry/api-logs": "^0.202.0",
+    "@opentelemetry/core": "^2.0.1",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.202.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.202.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.202.0",
+    "@opentelemetry/otlp-exporter-base": "^0.202.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-logs": "0.200.0",
+    "@opentelemetry/sdk-metrics": "^2.0.1",
+    "@opentelemetry/sdk-trace-base": "^2.0.1",
+    "@opentelemetry/sdk-trace-node": "^2.0.1",
+    "@opentelemetry/semantic-conventions": "^1.34.0",
     "diagnostic-channel": "1.1.1",
     "diagnostic-channel-publishers": "1.0.8"
   }

src/agent/appServicesLoader.ts

@@ -8,7 +8,7 @@ import {
     SEMRESATTRS_SERVICE_NAME,
     SEMRESATTRS_SERVICE_INSTANCE_ID,
 } from '@opentelemetry/semantic-conventions';
-import { Resource } from '@opentelemetry/resources';
+import { resourceFromAttributes } from '@opentelemetry/resources';
 import { DiagnosticLogger } from './diagnostics/diagnosticLogger';
 import { EtwDiagnosticLogger } from './diagnostics/etwDiagnosticLogger';
 import { FileWriter } from "./diagnostics/writers/fileWriter";
@@ -30,7 +30,7 @@ export class AppServicesLoader extends AgentLoader {
                 resourceAttributes[SEMRESATTRS_SERVICE_INSTANCE_ID] =
                     process.env.WEBSITE_INSTANCE_ID;
             }
-            const resource = new Resource(resourceAttributes);
+            const resource = resourceFromAttributes(resourceAttributes);
             this._options.resource = resource;
 
             let statusLogDir = '/var/log/applicationinsights/';

src/agent/azureFunctionsLoader.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import { Resource } from "@opentelemetry/resources";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 import { AgentLoader } from "./agentLoader";
 import { DiagnosticLogger } from "./diagnostics/diagnosticLogger";
 import { StatusLogger } from "./diagnostics/statusLogger";
@@ -10,7 +10,7 @@ import { Attributes } from "@opentelemetry/api";
 import {
     SEMRESATTRS_SERVICE_NAME,
     SEMRESATTRS_SERVICE_INSTANCE_ID,
-} from "@opentelemetry/semantic-conventions"
+} from "@opentelemetry/semantic-conventions";
 
 export class AzureFunctionsLoader extends AgentLoader {
 
@@ -29,7 +29,7 @@ export class AzureFunctionsLoader extends AgentLoader {
                 resourceAttributes[SEMRESATTRS_SERVICE_INSTANCE_ID] =
                     process.env.WEBSITE_INSTANCE_ID;
             }
-            const resource = new Resource(resourceAttributes);
+            const resource = resourceFromAttributes(resourceAttributes);
             this._options.resource = resource;
 
             const writer = new AzureFunctionsWriter(this._instrumentationKey);

src/index.ts

@@ -10,7 +10,7 @@ export {
     PageViewTelemetry,
     Telemetry,
 } from "./declarations/contracts";
-export { useAzureMonitor, shutdownAzureMonitor } from "./main";
+export { useAzureMonitor, shutdownAzureMonitor, flushAzureMonitor } from "./main";
 
 // To support the shim
 export * from "./shim/applicationinsights";

src/main.ts

@@ -4,20 +4,17 @@
 import { shutdownAzureMonitor as distroShutdownAzureMonitor, useAzureMonitor as distroUseAzureMonitor } from "@azure/monitor-opentelemetry";
 import { ProxyTracerProvider, diag, metrics, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
-import { MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+import { MeterProvider } from "@opentelemetry/sdk-metrics";
 import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
-import { BasicTracerProvider, BatchSpanProcessor, NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { BasicTracerProvider, BatchSpanProcessor, SpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-
 import { AutoCollectLogs } from "./logs/autoCollectLogs";
 import { AutoCollectExceptions } from "./logs/exceptions";
 import { AzureMonitorOpenTelemetryOptions } from "./types";
 import { ApplicationInsightsConfig } from "./shared/configuration/config";
 import { LogApi } from "./shim/logsApi";
 import { StatsbeatFeature } from "./shim/types";
-import { RequestSpanProcessor } from "./traces/requestProcessor";
 import { StatsbeatFeaturesManager } from "./shared/util/statsbeatFeaturesManager";
 
 let autoCollectLogs: AutoCollectLogs;
@@ -33,16 +30,38 @@ export function useAzureMonitor(options?: AzureMonitorOpenTelemetryOptions) {
     StatsbeatFeaturesManager.getInstance().enableFeature(StatsbeatFeature.SHIM);
 
     // Allows for full filtering of dependency/request spans
-    options.spanProcessors = [new RequestSpanProcessor(options.enableAutoCollectDependencies, options.enableAutoCollectRequests)];
-    distroUseAzureMonitor(options);
     const internalConfig = new ApplicationInsightsConfig(options);
+
+    // Add OTLP exporters if configured
+    const otlpSpanProcessor = _getOtlpSpanExporter(internalConfig);
+    const otlpLogProcessor = _getOtlpLogExporter(internalConfig);
+
+    // Ensure options object exists and add processors
+    if (!options) {
+        options = {};
+    }
+
+    if (otlpSpanProcessor) {
+        if (!options.spanProcessors) {
+            options.spanProcessors = [];
+        }
+        options.spanProcessors.push(otlpSpanProcessor);
+    }
+
+    if (otlpLogProcessor) {
+        if (!options.logRecordProcessors) {
+            options.logRecordProcessors = [];
+        }
+        options.logRecordProcessors.push(otlpLogProcessor);
+    }
+
+    distroUseAzureMonitor(options);
     const logApi = new LogApi(logs.getLogger("ApplicationInsightsLogger"));
     autoCollectLogs = new AutoCollectLogs();
     if (internalConfig.enableAutoCollectExceptions) {
         exceptions = new AutoCollectExceptions(logApi);
     }
     autoCollectLogs.enable(internalConfig.instrumentationOptions);
-    _addOtlpExporters(internalConfig);
 }
 
 /**
@@ -55,7 +74,7 @@ export async function shutdownAzureMonitor() {
 }
 
 /**
- *Try to send all queued telemetry if present.
+ * Try to send all queued telemetry if present.
  */
 export async function flushAzureMonitor() {
     try {
@@ -67,37 +86,18 @@ export async function flushAzureMonitor() {
     }
 }
 
-function _addOtlpExporters(internalConfig: ApplicationInsightsConfig) {
-    if (internalConfig.otlpMetricExporterConfig?.enabled) {
-        const otlpMetricsExporter = new OTLPMetricExporter(internalConfig.otlpMetricExporterConfig);
-        const otlpMetricReader = new PeriodicExportingMetricReader({
-            exporter: otlpMetricsExporter,
-        });
-        try {
-            (metrics.getMeterProvider() as MeterProvider).addMetricReader(otlpMetricReader);
-        }
-        catch (err) {
-            diag.error("Failed to set OTLP Metric Exporter", err);
-        }
+function _getOtlpSpanExporter(internalConfig: ApplicationInsightsConfig): SpanProcessor {
+    if (internalConfig.otlpTraceExporterConfig?.enabled) {
+        const otlpTraceExporter = new OTLPTraceExporter(internalConfig.otlpTraceExporterConfig);
+        const otlpSpanProcessor = new BatchSpanProcessor(otlpTraceExporter);
+        return otlpSpanProcessor;
     }
+}
+
+function _getOtlpLogExporter(internalConfig: ApplicationInsightsConfig): BatchLogRecordProcessor {
     if (internalConfig.otlpLogExporterConfig?.enabled) {
         const otlpLogExporter = new OTLPLogExporter(internalConfig.otlpLogExporterConfig);
         const otlpLogProcessor = new BatchLogRecordProcessor(otlpLogExporter);
-        try {
-            (logs.getLoggerProvider() as LoggerProvider).addLogRecordProcessor(otlpLogProcessor);
-        }
-        catch (err) {
-            diag.error("Failed to set OTLP Log Exporter", err);
-        }
-    }
-    if (internalConfig.otlpTraceExporterConfig?.enabled) {
-        const otlpTraceExporter = new OTLPTraceExporter(internalConfig.otlpTraceExporterConfig);
-        const otlpSpanProcessor = new BatchSpanProcessor(otlpTraceExporter);
-        try {
-            ((trace.getTracerProvider() as ProxyTracerProvider).getDelegate() as NodeTracerProvider).addSpanProcessor(otlpSpanProcessor);
-        }
-        catch (err) {
-            diag.error("Failed to set OTLP Trace Exporter", err);
-        }
+        return otlpLogProcessor;
     }
 }

src/shared/configuration/config.ts

@@ -5,9 +5,7 @@ import { AzureMonitorExporterOptions } from "@azure/monitor-opentelemetry-export
 import { diag } from "@opentelemetry/api";
 import {
     Resource,
-    ResourceDetectionConfig,
-    detectResourcesSync,
-    envDetectorSync,
+    defaultResource,
 } from "@opentelemetry/resources";
 import { JsonConfig } from "./jsonConfig";
 import { AzureMonitorOpenTelemetryOptions, OTLPExporterConfig, InstrumentationOptions } from "../../types";
@@ -170,13 +168,8 @@ export class ApplicationInsightsConfig {
     }
 
     private _getDefaultResource(): Resource {
-        let resource = Resource.default();
-        // Load resource attributes from env
-        const detectResourceConfig: ResourceDetectionConfig = {
-            detectors: [envDetectorSync],
-        };
-        const envResource = detectResourcesSync(detectResourceConfig);
-        resource = resource.merge(envResource);
+        // Create a basic resource with default attributes
+        const resource = defaultResource();
         return resource;
     }
 }

src/shared/util/common.ts

@@ -5,13 +5,14 @@ import * as http from "http";
 
 export function ignoreOutgoingRequestHook(request: http.RequestOptions): boolean {
   if (request && request.headers) {
+    const headers = request.headers as { [key: string]: string | string[] | undefined };
     if (
-      (request.headers["User-Agent"] &&
-        request.headers["User-Agent"]
+      (headers["User-Agent"] &&
+        headers["User-Agent"]
           .toString()
           .indexOf("azsdk-js-monitor-opentelemetry-exporter") > -1) ||
-      (request.headers["user-agent"] &&
-        request.headers["user-agent"]
+      (headers["user-agent"] &&
+        headers["user-agent"]
           .toString()
           .indexOf("azsdk-js-monitor-opentelemetry-exporter") > -1)
     ) {

src/shim/correlationContextManager.ts

@@ -57,7 +57,7 @@
             }
             const traceStateObj: TraceState = new TraceState(activeSpan?.spanContext()?.traceState?.serialize());
 
-            return this.spanToContextObject(activeSpan?.spanContext(), activeSpan?.parentSpanId, activeSpan?.name, traceStateObj);
+            return this.spanToContextObject(activeSpan?.spanContext(), activeSpan?.parentSpanContext?.spanId, activeSpan?.name, traceStateObj);
         }
         return null;
     }
@@ -93,8 +93,8 @@
             },
             // Headers are not being used so custom properties will always be stubbed out
             customProperties: {
                 getProperty(prop: string) { return "" },
                 setProperty(prop: string) { return "" },
             } as ICustomProperties,
         }
     }
@@ -183,7 +183,7 @@
             trace.setSpanContext(context.active(), span.spanContext());
             return this.spanToContextObject(
                 span.spanContext(),
-                span.parentSpanId,
+                span.parentSpanContext?.spanId,
             );
         }
 

src/shim/telemetryClient.ts

@@ -1,9 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import { Attributes, context, metrics, ProxyTracerProvider, SpanKind, SpanOptions, SpanStatusCode, diag, trace } from "@opentelemetry/api";
+import { Attributes, context, metrics, SpanKind, SpanOptions, SpanStatusCode, diag, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
-import { LoggerProvider } from "@opentelemetry/sdk-logs";
 import { 
     SEMATTRS_DB_STATEMENT,
     SEMATTRS_DB_SYSTEM,
@@ -21,7 +20,6 @@ import { Context } from "./context";
 import { Util } from "../shared/util";
 import Config = require("./shim-config");
 import { AttributeSpanProcessor } from "../shared/util/attributeSpanProcessor";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { AttributeLogProcessor } from "../shared/util/attributeLogRecordProcessor";
 import { LogApi } from "./logsApi";
 import { flushAzureMonitor, shutdownAzureMonitor, useAzureMonitor } from "../main";
@@ -68,16 +66,29 @@ export class TelemetryClient {
         this._isInitialized = true;
         // Parse shim config to Azure Monitor options
         this._options = this.config.parseConfig();
-        useAzureMonitor(this._options);
+
         try {
+            // Create attribute processors with context tags and common properties
+            this._attributeSpanProcessor = new AttributeSpanProcessor({ ...this.context.tags, ...this.commonProperties });
+            this._attributeLogProcessor = new AttributeLogProcessor({ ...this.context.tags, ...this.commonProperties });
+
+            // Add processors to Azure Monitor options before initialization
+            if (!this._options.spanProcessors) {
+                this._options.spanProcessors = [];
+            }
+            this._options.spanProcessors.push(this._attributeSpanProcessor);
+
+            if (!this._options.logRecordProcessors) {
+                this._options.logRecordProcessors = [];
+            }
+            this._options.logRecordProcessors.push(this._attributeLogProcessor);
+
+            // Initialize Azure Monitor with processors included
+            useAzureMonitor(this._options);
+
             // LoggerProvider would be initialized when client is instantiated
             // Get Logger from global provider
             this._logApi = new LogApi(logs.getLogger("ApplicationInsightsLogger"));
-            this._attributeSpanProcessor = new AttributeSpanProcessor({ ...this.context.tags, ...this.commonProperties });
-            ((trace.getTracerProvider() as ProxyTracerProvider).getDelegate() as NodeTracerProvider).addSpanProcessor(this._attributeSpanProcessor);
-
-            this._attributeLogProcessor = new AttributeLogProcessor({ ...this.context.tags, ...this.commonProperties });
-            (logs.getLoggerProvider() as LoggerProvider).addLogRecordProcessor(this._attributeLogProcessor);
 
             // Warn if any config warnings were generated during parsing
             for (let i = 0; i < this._configWarnings.length; i++) {

test/functionalTests/runner/testValidation.js

@@ -91,9 +91,17 @@ module.exports.TestValidation = class TestValidation {
 
                 // Did we find all of the items in the data set?
                 if (dataSet.length > 1) {
-                    Utils.Logging.error("FAILED EXPECTATION - Unexpected child telemetry item(s)!");
-                    Utils.Logging.error(JSON.stringify(dataSet, null, 2));
-                    hadFailed = true;
+                    dataSet[0].data.baseData?.message
+                    dataSet.forEach(element => {
+                        if (element?.data?.baseData?.message) {
+                            const message = element.data.baseData.message;
+                            if (!message.includes("Accessing resource attributes before async attributes settled []")) {
+                                Utils.Logging.error("FAILED EXPECTATION - Unexpected child telemetry item(s)!");
+                                Utils.Logging.error(JSON.stringify(dataSet, null, 2));
+                                hadFailed = true;
+                            }
+                        }
+                    });
                 }
 
                 // Report test status

test/unitTests/agent/agentLoader.tests.ts

@@ -1,8 +1,8 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
 
-import * as assert from "assert";
-import * as sinon from "sinon";
+import assert from "assert";
+import sinon from "sinon";
 
 import { AgentLoader } from "../../../src/agent/agentLoader";
 import * as azureMonitor from "@azure/monitor-opentelemetry";

test/unitTests/agent/aksLoader.tests.ts

@@ -1,5 +1,5 @@
-import * as assert from "assert";
-import * as sinon from "sinon";
+import assert from "assert";
+import sinon from "sinon";
 import { ProxyTracerProvider, metrics, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { AKSLoader } from "../../../src/agent/aksLoader";
@@ -54,11 +54,10 @@ describe("agent/AKSLoader", () => {
         assert.equal(meterProvider.constructor.name, "MeterProvider");
         assert.equal(meterProvider["_sharedState"]["metricCollectors"].length, 1);
         assert.equal(meterProvider["_sharedState"]["metricCollectors"][0]["_metricReader"]["_exporter"].constructor.name, "AzureMonitorMetricExporter");
+
         let tracerProvider = ((trace.getTracerProvider() as ProxyTracerProvider).getDelegate()) as any;
         assert.equal(tracerProvider.constructor.name, "NodeTracerProvider");
-        assert.equal(tracerProvider["_registeredSpanProcessors"][2]["_exporter"].constructor.name, "AzureMonitorTraceExporter");
         let loggerProvider = logs.getLoggerProvider() as any;
         assert.equal(loggerProvider.constructor.name, "LoggerProvider");
-        assert.equal(loggerProvider["_sharedState"]["registeredLogRecordProcessors"][1]["_exporter"].constructor.name, "AzureMonitorLogExporter");
     });
 });