*** Urgent Help: *** | Open Telemetry support for Azure Application Insights and Dynatrace

[smo043]

Hello Team - We are using the most recent version of Azure Functions, Open Telemetry, and Dynatrace packages, and I would like both application insights and Dynatrace to work concurrently without any problems. At the moment, we are observing only one functioning at a time. Any assistance would be greatly valued.

Documentation Link for Dynatrace

Dependencies:

"@azure/functions": "^4.6.0",
"@dynatrace/opentelemetry-azure-functions": "^1.301.2",
"@dynatrace/opentelemetry-core": "^1.301.2",
"@azure/monitor-opentelemetry-exporter": "^1.0.0-beta.27",
"@opencensus/propagation-tracecontext": "^0.1.0",
"@opentelemetry/api": "^1.9.0",
"@opentelemetry/context-async-hooks": "^1.27.0",
"@opentelemetry/core": "^1.27.0",
"@opentelemetry/instrumentation": "^0.54.0",
"@opentelemetry/instrumentation-http": "^0.54.0",
"@opentelemetry/resources": "^1.27.0",
"@opentelemetry/sdk-trace-base": "^1.27.0",
"@opentelemetry/sdk-trace-node": "^1.27.0",
"@opentelemetry/semantic-conventions": "^1.27.0"

Code:

import {
  diag,
  DiagConsoleLogger,
  DiagLogLevel,
  trace,
  context,
  SpanKind,
  SpanStatusCode,
  type Exception,
  type Tracer,
  type Span,
  type Attributes
} from '@opentelemetry/api';
import {AsyncHooksContextManager} from '@opentelemetry/context-async-hooks';
import {Resource} from '@opentelemetry/resources';
import {ConsoleSpanExporter, SimpleSpanProcessor, type SpanExporter} from '@opentelemetry/sdk-trace-base';
import {NodeTracerProvider} from '@opentelemetry/sdk-trace-node';
import {ATTR_SERVICE_NAME} from '@opentelemetry/semantic-conventions';
import {AzureMonitorTraceExporter} from '@azure/monitor-opentelemetry-exporter';
import {parseTraceParent} from '@opentelemetry/core';
import {registerInstrumentations} from '@opentelemetry/instrumentation';
import {HttpInstrumentation} from '@opentelemetry/instrumentation-http';
import {DtSpanExporter} from '@dynatrace/opentelemetry-core';

import {getInvocationId} from '../utils/TraceHeaders';
import {generateTraceId} from '../utils/TraceIdGenerator/index';

export const TRACEPARENT = 'traceparent';
export const BASE_SPAN_NAME = 'base_span_name';
export const MAIN_SPAN = 'Main';

export class TelemetryService {
  static instance: TelemetryService;

  private tracer: Tracer;

  private spanRegistry: Map<string, Span>;

  constructor(appName: string) {
    const isDebug = process.env['DEBUG'] === 'true';
    const {provider, exporters, tracer} = this.initialize(appName);

    this.spanRegistry = new Map<string, Span>();
    this.tracer = tracer;

    exporters.forEach((exporter) => {
      provider?.addSpanProcessor?.(new SimpleSpanProcessor(exporter));
    });

    if (isDebug) {
      diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG);
      provider?.addSpanProcessor?.(new SimpleSpanProcessor(new ConsoleSpanExporter()));
    }

    registerInstrumentations({
      tracerProvider: provider,
      instrumentations: [new HttpInstrumentation()]
    });
  }

  private initialize(appName: string) {
    try {
      const provider = this.getTracerProvider(appName);
      const exporters = this.getExporters();
      const tracer = this.getTracer(appName);
      const contextManager = this.getContextManager();

      return {
        provider,
        exporters,
        tracer,
        contextManager
      };
    } catch {
      throw new Error('Unable to initialize Telemetry Service.');
    }
  }

  /**
   * Method to return singleton instance of the logger class.
   * @param appName Name of app to initialize this instance with.
   * @returns singleton logger instance.
   */
  static getInstance(appName: string, rootTraceId?: string): TelemetryService {
    if (!TelemetryService.instance) {
      TelemetryService.instance = new TelemetryService(appName);
    }

    const rtId = rootTraceId ?? generateTraceId();
    TelemetryService.instance.createRootSpan(rtId);

    return TelemetryService.instance;
  }

  getMainSpanName(invocationId: string): string {
    return `${MAIN_SPAN}-${invocationId}`;
  }

  getChildSpanName(spanName: string, invocationId = ''): string {
    return `${spanName}-${invocationId}`;
  }

  private getTracer(appName: string) {
    return trace.getTracer(appName);
  }

  private getContextManager() {
    try {
      const contextManager = new AsyncHooksContextManager();
      contextManager.enable();
      context.setGlobalContextManager(contextManager);

      return contextManager;
    } catch (error) {
      // eslint-disable-next-line no-console
      console.error(error);

      return undefined;
    }
  }

  private getTracerProvider(appName: string) {
    try {
      return new NodeTracerProvider({
        resource: new Resource({
          [ATTR_SERVICE_NAME]: appName,
          'deployment.environment': process.env['NODE_ENV']
        })
      });
    } catch (error) {
      // eslint-disable-next-line no-console
      console.error(error);

      return undefined;
    }
  }

  private getExporters() {
    const exporters: SpanExporter[] = [];

    try {
      const connectionString = process.env['APPLICATIONINSIGHTS_CONNECTION_STRING'];
      if (connectionString) {
        exporters.push(new AzureMonitorTraceExporter({connectionString}));
      } else {
        throw new Error('Application Insights connection string environment variable is missing.');
      }
    } catch (error) {
      // eslint-disable-next-line no-console
      console.error(error);
    }

    try {
      const dynatraceExporter = new DtSpanExporter();
      exporters.push(dynatraceExporter);
    } catch (error) {
      // eslint-disable-next-line no-console
      console.error(error);
    }

    return exporters;
  }

  private createRootSpan(rootTraceId: string) {
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    const headerContext = parseTraceParent(rootTraceId)!;
    const invocationId = getInvocationId(rootTraceId);
    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
    const mainSpanName = this.getMainSpanName(invocationId);

    const baseContext = trace.setSpanContext(context.active(), headerContext);
    const parentSpan = this.tracer.startSpan(mainSpanName, undefined, baseContext);

    trace.setSpan(context.active(), parentSpan);

    this.spanRegistry.set(mainSpanName, parentSpan);

    return parentSpan;
  }

  createChildSpan(name: string, parentSpan?: string, invocationId = '', attributes?: Attributes, kind?: SpanKind) {
    const sparentSpan = parentSpan ?? MAIN_SPAN;
    const spanName = `${sparentSpan}-${invocationId}`;
    const SpanFromMap = this.spanRegistry.get(spanName);

    if (SpanFromMap) {
      trace.setSpan(context.active(), SpanFromMap);
      const options = (attributes ?? kind) ? {attributes, kind} : undefined;

      const ctx = trace.setSpanContext(context.active(), SpanFromMap.spanContext());
      const span = this.tracer.startSpan(name, options, ctx);
      const childSpanName = this.getChildSpanName(name, invocationId);

      this.spanRegistry.set(childSpanName, span);

      return span;
    }

    return undefined;
  }

  endSpan(span: string, invocationId: string, responsemessage = '') {
    const spanName = `${span}-${invocationId}`;
    const storedSpan = this.spanRegistry.get(spanName);

    if (storedSpan) {
      storedSpan.setStatus({
        code: SpanStatusCode.OK
      });

      storedSpan.setAttribute('ResponseMessage:', responsemessage);
      storedSpan.end();

      this.spanRegistry.delete(spanName);
    }
  }

  /**
   * This method removes the entries from the Map that has the given invocation
   * @param invocationId Invocation IDs to be removed from the Map.
   */
  removeElementsForGivenInvocationId(invocationId: string) {
    if (this.spanRegistry.size) {
      Array.from(this.spanRegistry.keys()).forEach((key) => {
        if (key.includes(invocationId)) {
          this.spanRegistry.delete(key);
        }
      });
    }
  }

  addEvent(eventName: string, severity: string, message: string, timeStamp: string, spanName: string) {
    const storedSpan = this.spanRegistry.get(spanName);

    if (storedSpan) {
      storedSpan.addEvent(eventName, {
        severity,
        message,
        timeStamp
      });
    }
  }

  recordException(error: Exception, span: string, invocationId: string) {
    const spanName = this.getChildSpanName(span, invocationId);
    const storedSpan = this.spanRegistry.get(spanName);
    if (storedSpan) {
      storedSpan.recordException(error);
      storedSpan.setStatus({
        code: SpanStatusCode.ERROR
      });

      const mainSpanName = `${MAIN_SPAN}-${invocationId}`;
      const mainSpan = this.spanRegistry.get(mainSpanName);
      storedSpan.end();

      if (mainSpan) {
        mainSpan.end();
      }

      this.removeElementsForGivenInvocationId(invocationId);
    }
  }

  cleanup() {
    Array.from(this.spanRegistry.keys()).forEach((key) => {
      const span = this.spanRegistry.get(key);
      if (span) {
        span.end();
      }
    });
    this.spanRegistry.clear();
  }
}