SSR, ContextManager, Propagation and tracerProviders

[Nighttraveler]

Hi guys,
We finished setting up a JAVA service and to continue with distributed tracing we want to add Otel to a Next.js app in a monorepo setup.
We have some issues with multiple registrations of the API, with that fixed, now the context manager seems not to be working properly.

• Does the BasicTracerProvider ships with a ContextManager ?
  We tried with AsyncHooksContextManager but next.js complains about it, even in the server side, I guess while doing the SSR?

error - ../node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js:20:0
Module not found: Can't resolve 'async_hooks'

Import trace for requested module:
../node_modules/@opentelemetry/context-async-hooks/build/src/index.js
../node_modules/@opentelemetry/sdk-trace-node/build/src/NodeTracerProvider.js
../node_modules/@opentelemetry/sdk-trace-node/build/src/index.js
../shared/utils/OpenTelemetryAPM.ts
./pages/_app.tsx

We manage to use ZoneContextManager in the frontend with a local require import.
We tried in the server to use the StackedContextManager provided in Web SDK but no luck with it.
Which brings me to the next question:

• Do we always need the parent at hand to start a child span? I expected that a child get the context from the recently created parent
  For example :

...
  const operationNames = getOperationNames();
  const fetchUrl = `${api}?opname=${operationNames}`;
  log.trace('Fetching %s from %s with options: %O', operationNames, api, requestInfo(options));
  const span = tracer.startSpan(`apolloFetch/apolloFetch.${operationNames}`);
  span.setAttribute('api', `${api}`);
  // startSpan set the context.active() to the new child span
  const childSpan = tracer.startSpan(`child of apolloFetch/apolloFetch.${operationNames}`);
  onBeforeFetch(options);
  const now = performance.now();
  const response = await doFetch(fetchUrl, options);
....

Here is the initialization code:

import { BatchSpanProcessor, BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
// import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
import { WebTracerProvider, StackContextManager } from '@opentelemetry/sdk-trace-web';
import { OTLPTraceExporter, OTLPMetricExporter } from '@opentelemetry/exporter-otlp-http';
import { MeterProvider } from '@opentelemetry/sdk-metrics-base';
import { Resource } from '@opentelemetry/resources';
import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import api, {
  diag,
  DiagConsoleLogger,
  DiagLogLevel,
  Span,
  SpanOptions,
  SpanStatusCode
} from '@opentelemetry/api';
import { metrics } from '@opentelemetry/api-metrics';
import { B3Propagator, B3InjectEncoding } from '@opentelemetry/propagator-b3';
import { CompositePropagator, W3CTraceContextPropagator } from '@opentelemetry/core';
import { getLog } from './log';

export function startDiag() {
  diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
}

const log = getLog(module);
export class OpenTelemetryAPM {
  public static initServerAPM() {
    if (process.env.SERVER_OTEL_ENABLED === 'true') {
      if (log.isLevelEnabled('info')) {
        startDiag();
      }
      log.info('OPENTELEMETRY ENABLED for server side');
      /* error - ../node_modules/@opentelemetry/context-async-hooks/build/src/AsyncHooksContextManager.js:20:0
      Module not found: Can't resolve 'async_hooks'
      Import trace for requested module:
        ../node_modules/@opentelemetry/context-async-hooks/build/src/index.js
        ../shared/utils/OpenTelemetryAPM.ts
        ./pages/_app.tsx
      // eslint-disable-next-line @typescript-eslint/no-var-requires
      const { AsyncHooksContextManager } = require('@opentelemetry/context-async-hooks'); */

      const resource = this.getResource();
      // const tracerProvider = new NodeTracerProvider({ Module not found: Can't resolve 'async_hooks'
      const tracerProvider = new BasicTracerProvider({
        resource
      });
      const exporter = new OTLPTraceExporter();
      tracerProvider.addSpanProcessor(
        new BatchSpanProcessor(exporter, {
          // The maximum queue size. After the size is reached spans are dropped.
          maxQueueSize: 1000,
          // The interval between two consecutive exports
          scheduledDelayMillis: 1000
        })
      );

      const contextManager = new StackContextManager().enable();

      /**
       * Initialize the OpenTelemetry APIs to use the BasicTracerProvider bindings.
       *
       * This registers the tracer provider with the OpenTelemetry API as the global
       * tracer provider. This means when you call API methods like
       * `openTelemetry.trace.getTracer`, they will use this tracer provider. If you
       * do not register a global tracer provider, instrumentation which calls these
       * methods will receive no-op implementations.
       */
      tracerProvider.register({
        propagator: new CompositePropagator({
          propagators: [
            new B3Propagator(),
            new B3Propagator({ injectEncoding: B3InjectEncoding.MULTI_HEADER }),
            new W3CTraceContextPropagator()
          ]
        }),
        contextManager
        // contextManager: new AsyncHooksContextManager()
      });
      api.context.setGlobalContextManager(contextManager);
      this.initMetrics();

      registerInstrumentations({
        instrumentations: [
          getNodeAutoInstrumentations({
            '@opentelemetry/instrumentation-http': {
              ignoreOutgoingUrls: [
                'http://localhost:55681/v1/metrics',
                'http://localhost:55681/v1/traces'
              ]
            }
          })
        ]
      });
    }
  }

  public static initClientAPM() {
    // workaround to init client side, SERVER_OTEL_ENABLED is not available on client side
    if (process.env.NEXT_PUBLIC_OTEL_ENABLED === 'true' && !process.env.SERVER_OTEL_ENABLED) {
      // using log.isLevelEnabled('trace') throws errors
      if (process.env.NEXT_PUBLIC_LOG_LEVEL === 'info') {
        startDiag();
      }
      // if we use import for ZoneContextManager at the top in server side,
      // we get a FATAL Error since zone.js is meant for client side
      // https://github.com/open-telemetry/opentelemetry-js/blob/main/packages/opentelemetry-context-zone/README.md
      // eslint-disable-next-line @typescript-eslint/no-var-requires,global-require
      const { ZoneContextManager } = require('@opentelemetry/context-zone');
      log.info('OPENTELEMETRY ENABLED for client side');

      const resource = this.getResource();
      const tracerProvider = new BasicTracerProvider({
        resource
      });
      const exporter = new OTLPTraceExporter();
      tracerProvider.addSpanProcessor(
        new BatchSpanProcessor(exporter, {
          // The maximum queue size. After the size is reached spans are dropped.
          maxQueueSize: 1000,
          // The interval between two consecutive exports
          scheduledDelayMillis: 10000
        })
      );
      const contextManager = new ZoneContextManager().enable();

      /**
       * Initialize the OpenTelemetry APIs to use the WebTracerProvider bindings.
       *
       * This registers the tracer provider with the OpenTelemetry API as the global
       * tracer provider. This means when you call API methods like
       * `openTelemetry.trace.getTracer`, they will use this tracer provider. If you
       * do not register a global tracer provider, instrumentation which calls these
       * methods will receive no-op implementations.
       */
      tracerProvider.register({
        propagator: new CompositePropagator({
          propagators: [
            new B3Propagator(),
            new B3Propagator({ injectEncoding: B3InjectEncoding.MULTI_HEADER }),
            new W3CTraceContextPropagator()
          ]
        }),
        contextManager
      });
      api.context.setGlobalContextManager(contextManager);
      this.initMetrics();
    }
  }

  private static initMetrics() {
    const metricExporter = new OTLPMetricExporter();
    const meterProvider = new MeterProvider({
      exporter: metricExporter,
      interval: 1000,
      resource: this.getResource()
    });
    metrics.setGlobalMeterProvider(meterProvider);
  }

  private static getResource(): Resource {
    const service_name = `${process.env.NEXT_PUBLIC_AURORA_SERVICE_NAME}${
      !process.env.UNIVERSE ? '.client' : ''
    }`;
    return new Resource({
      [SemanticResourceAttributes.SERVICE_NAME]: service_name
    });
  }
}

export const tracer = api.trace.getTracer(`aurora.tracer.${process.env.UNIVERSE || 'client'}`);
export const meter = metrics.getMeter(`aurora.meter.${process.env.UNIVERSE || 'client'}`);

export function setErrorStatus(span: Span, error: Error): void {
  span.setStatus({
    code: SpanStatusCode.ERROR,
    message: error.message
  });
}

export function recordException(span: Span, exception: Error): void {
  span.recordException(exception);
}

export function startChildSpan(parentSpan: Span, name: string, options: SpanOptions) {
  return tracer.startSpan(name, options, api.trace.setSpan(api.context.active(), parentSpan));
}
// We export the api here b/c this way we don't have add the deps in all package.json monorepo files
export default api;