nestjs-otel 2.6.1 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-otel",
-  "version": "2.6.1",
+  "version": "3.0.2",
   "description": "NestJS OpenTelemetry Library",
   "main": "lib/index.js",
   "typings": "lib/index",
@@ -14,7 +14,7 @@
     "test:coverage": "jest --coverage",
     "test:unit": "jest --passWithNoTests",
     "test:watch": "jest --watch",
-    "test:e2e": "jest --config ./tests/jest-e2e.json --runInBand --detectOpenHandles",
+    "test:e2e": "jest --config ./tests/jest-e2e.json --runInBand --forceExit",
     "test:e2e:watch": "jest --config ./tests/jest-e2e.json --runInBand --watch"
   },
   "repository": {
@@ -31,47 +31,46 @@
   ],
   "author": "pragmaticivan@gmail.com",
   "license": "Apache-2.0",
-  "test": "jest --ci --runInBand",
   "bugs": {
     "url": "https://github.com/pragmaticivan/nestjs-otel/issues"
   },
   "homepage": "https://github.com/pragmaticivan/nestjs-otel#readme",
   "dependencies": {
-    "@opentelemetry/host-metrics": "^0.25.0",
-    "@opentelemetry/api": "^1.0.3",
-    "@opentelemetry/api-metrics": "^0.25.0",
-    "@opentelemetry/metrics": "^0.24.0",
-    "opentelemetry-node-metrics": "^1.0.3",
+    "@opentelemetry/host-metrics": "^0.27.0",
+    "@opentelemetry/api": "^1.0.4",
+    "@opentelemetry/api-metrics": "^0.27.0",
+    "opentelemetry-node-metrics": "^1.1.0",
     "response-time": "^2.3.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "^13.1.0",
-    "@commitlint/config-conventional": "^13.1.0",
-    "@nestjs/common": "^8.0.10",
-    "@nestjs/core": "^8.0.10",
-    "@nestjs/platform-express": "^8.0.10",
-    "@nestjs/platform-fastify": "^8.0.10",
-    "@nestjs/testing": "^8.0.10",
-    "@opentelemetry/exporter-prometheus": "^0.25.0",
-    "@opentelemetry/sdk-node": "^0.25.0",
-    "@types/jest": "^27.0.2",
-    "@types/node": "^16.9.6",
+    "@commitlint/cli": "^16.0.1",
+    "@commitlint/config-conventional": "^16.0.0",
+    "@nestjs/common": "^8.2.3",
+    "@nestjs/core": "^8.2.3",
+    "@nestjs/platform-express": "^8.2.4",
+    "@nestjs/platform-fastify": "^8.2.4",
+    "@nestjs/testing": "^8.2.4",
+    "@opentelemetry/exporter-prometheus": "^0.27.0",
+    "@opentelemetry/sdk-node": "^0.27.0",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^17.0.5",
     "@types/supertest": "^2.0.11",
-    "@typescript-eslint/eslint-plugin": "4.31.2",
-    "@typescript-eslint/parser": "4.31.2",
-    "eslint": "^7.32.0",
-    "eslint-config-airbnb-base": "^14.2.1",
-    "eslint-config-airbnb-typescript": "^14.0.1",
-    "eslint-plugin-import": "^2.25.1",
-    "husky": "^7.0.2",
-    "jest": "^27.2.1",
-    "lint-staged": "^11.1.2",
+    "@typescript-eslint/eslint-plugin": "5.8.1",
+    "@typescript-eslint/parser": "5.8.1",
+    "eslint": "^8.5.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^16.1.0",
+    "eslint-plugin-import": "^2.25.3",
+    "husky": "^7.0.4",
+    "jest": "^27.4.5",
+    "lint-staged": "^12.1.4",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",
-    "rxjs": "^7.3.0",
+    "rxjs": "^7.5.1",
     "supertest": "^6.1.6",
-    "ts-jest": "^27.0.5",
-    "typescript": "4.4.3"
+    "ts-jest": "^27.1.2",
+    "typescript": "4.5.4",
+    "ansi-regex": ""
   },
   "peerDependencies": {
     "@nestjs/common": "^7.0.0 || ^8.0.0",
@@ -96,7 +95,7 @@
     "testEnvironment": "node"
   },
   "lint-staged": {
-    "*.{js,ts}": "eslint --cache --fix"
+    "!(examples/**/*)*.{js,ts}": "eslint --cache --fix"
   },
   "commitlint": {
     "extends": [

package/src/interfaces/opentelemetry-options.interface.ts

@@ -1,12 +1,12 @@
 import { ModuleMetadata, Type, Abstract } from '@nestjs/common';
-import { Labels } from '@opentelemetry/api-metrics';
+import { Attributes } from '@opentelemetry/api-metrics';
 import { RouteInfo } from '@nestjs/common/interfaces';
 
 export type OpenTelemetryModuleOptions = {
   /**
    * OpenTelemetry Metrics Setup
    */
-  metrics?: OpenTelemetryMetrics
+  metrics?: OpenTelemetryMetrics;
 };
 
 export interface OpenTelemetryOptionsFactory {
@@ -52,7 +52,7 @@ export type OpenTelemetryMetrics = {
     timeBuckets?: number[],
     requestSizeBuckets?: number[],
     responseSizeBuckets?: number[],
-    defaultLabels?: Labels,
+    defaultAttributes?: Attributes,
     ignoreRoutes?: (string | RouteInfo)[],
     ignoreUndefinedRoutes?: boolean,
   },

package/src/metrics/decorators/common.ts

@@ -1,5 +1,5 @@
 import { Counter, MetricOptions } from '@opentelemetry/api-metrics';
-import { getOrCreateCounter, getOrCreateValueRecorder, MetricType } from '../metric-data';
+import { getOrCreateCounter } from '../metric-data';
 
 /**
  * Create and increment a counter when a new instance is created
@@ -16,7 +16,7 @@ export const OtelInstanceCounter = (
   return class extends ctor {
     constructor(...args) {
       if (!counterMetric) {
-        counterMetric = getOrCreateCounter(name, MetricType.Counter, { description, ...options });
+        counterMetric = getOrCreateCounter(name, { description, ...options });
       }
 
       counterMetric.add(1);
@@ -31,7 +31,9 @@ export const OtelInstanceCounter = (
 export const OtelMethodCounter = (
   options?: MetricOptions,
 ) => (
-  target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]
+  target: Object,
+  propertyKey: string | symbol,
+  descriptor: TypedPropertyDescriptor<(...args: any[]
   ) => any>,
 ) => {
   const className = target.constructor.name;
@@ -42,7 +44,7 @@ export const OtelMethodCounter = (
   // eslint-disable-next-line no-param-reassign, func-names
   descriptor.value = function (...args: any[]) {
     if (!counterMetric) {
-      counterMetric = getOrCreateCounter(name, MetricType.Counter, { description, ...options });
+      counterMetric = getOrCreateCounter(name, { description, ...options });
     }
     counterMetric.add(1);
     return methodFunc.apply(this, args);

package/src/metrics/decorators/counter.ts

@@ -1,21 +1,17 @@
 import { createParamDecorator } from '@nestjs/common';
 import { MetricOptions } from '@opentelemetry/api-metrics';
-import { getOrCreateCounter, getOrCreateValueRecorder, MetricType } from '../metric-data';
+import { getOrCreateCounter, MetricType } from '../metric-data';
 
-export const OtelCounter = createParamDecorator((
-  name: string, options?: MetricOptions,
-) => {
+export const OtelCounter = createParamDecorator((name: string, options?: MetricOptions) => {
   if (!name || name.length === 0) {
     throw new Error('OtelCounter need a name argument');
   }
-  return getOrCreateCounter(name, MetricType.Counter, options);
+  return getOrCreateCounter(name, options);
 });
 
-export const OtelUpDownCounter = createParamDecorator((
-  name: string, options?: MetricOptions,
-) => {
+export const OtelUpDownCounter = createParamDecorator((name: string, options?: MetricOptions) => {
   if (!name || name.length === 0) {
     throw new Error('OtelUpDownCounter need a name argument');
   }
-  return getOrCreateCounter(name, MetricType.UpDownCounter, options);
+  return getOrCreateCounter(name, options);
 });

package/src/metrics/decorators/histogram.ts

@@ -0,0 +1,10 @@
+import { createParamDecorator } from '@nestjs/common';
+import { MetricOptions } from '@opentelemetry/api-metrics';
+import { getOrCreateHistogram } from '../metric-data';
+
+export const OtelHistogram = createParamDecorator((name: string, options?: MetricOptions) => {
+  if (!name || name.length === 0) {
+    throw new Error('OtelHistogram need a name argument');
+  }
+  return getOrCreateHistogram(name, options);
+});

package/src/metrics/decorators/observable.ts

@@ -0,0 +1,28 @@
+import { createParamDecorator } from '@nestjs/common';
+import { MetricOptions } from '@opentelemetry/api-metrics';
+import { getOrCreateObservableCounter, getOrCreateObservableGauge, getOrCreateObservableUpDownCounter } from '../metric-data';
+
+export const OtelObservableGauge = createParamDecorator((name: string, options?: MetricOptions) => {
+  if (!name || name.length === 0) {
+    throw new Error('OtelObservableGauge need a name argument');
+  }
+  return getOrCreateObservableGauge(name, options);
+});
+
+export const OtelObservableCounter = createParamDecorator(
+  (name: string, options?: MetricOptions) => {
+    if (!name || name.length === 0) {
+      throw new Error('OtelObservableCounter need a name argument');
+    }
+    return getOrCreateObservableCounter(name, options);
+  },
+);
+
+export const OtelObservableUpDownCounter = createParamDecorator(
+  (name: string, options?: MetricOptions) => {
+    if (!name || name.length === 0) {
+      throw new Error('OtelObservableUpDownCounter need a name argument');
+    }
+    return getOrCreateObservableUpDownCounter(name, options);
+  },
+);

package/src/metrics/metric-data.ts

@@ -1,56 +1,116 @@
 import {
-  Counter, MetricOptions, metrics, UpDownCounter, ValueRecorder,
+  Counter, MetricOptions, metrics, UpDownCounter,
+  Histogram, ObservableGauge, ObservableCounter, ObservableUpDownCounter, ObservableResult,
 } from '@opentelemetry/api-metrics';
 import { OTEL_METER_NAME } from '../opentelemetry.constants';
 
-export type GenericMetric = Counter | UpDownCounter | ValueRecorder;
+export type GenericMetric =
+  Counter |
+  UpDownCounter |
+  Histogram |
+  ObservableGauge |
+  ObservableCounter |
+  ObservableUpDownCounter;
 
 export enum MetricType {
   'Counter' = 'Counter',
   'UpDownCounter' = 'UpDownCounter',
-  'ValueRecorder' = 'ValueRecorder',
+  'Histogram' = 'Histogram',
+  'ObservableGauge' = 'ObservableGauge',
+  'ObservableCounter' = 'ObservableCounter',
+  'ObservableUpDownCounter' = 'ObservableUpDownCounter',
 }
 
 export const meterData: Map<string, GenericMetric> = new Map();
 
-export function getOrCreateValueRecorder(
-  name: string, type: MetricType, options: MetricOptions,
-): ValueRecorder {
+export function getOrCreateHistogram(
+  name: string,
+  options: MetricOptions,
+): Histogram {
   if (meterData.has(name)) {
-    return meterData.get(name) as ValueRecorder;
+    return meterData.get(name) as Histogram;
   }
 
   const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
+  const histogram = meter.createHistogram(name, options);
+  meterData.set(name, histogram);
+  return histogram;
+}
 
-  switch (type) {
-    case MetricType.ValueRecorder:
-      const valueRecorder = meter.createValueRecorder(name, options);
-      meterData.set(name, valueRecorder);
-      return valueRecorder;
-    default:
-      throw new Error(`Unknown type: ${type}`);
+export function getOrCreateCounter(
+  name: string,
+  options: MetricOptions,
+): Counter {
+  if (meterData.has(name)) {
+    return meterData.get(name) as Counter;
   }
+
+  const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
+
+  const counter = meter.createCounter(name, options);
+  meterData.set(name, counter);
+  return counter;
 }
 
-export function getOrCreateCounter(
-  name: string, type: MetricType, options: MetricOptions,
-): Counter | UpDownCounter {
+export function getOrCreateUpDownCounter(
+  name: string,
+  options: MetricOptions,
+): UpDownCounter {
   if (meterData.has(name)) {
-    return meterData.get(name) as Counter | UpDownCounter;
+    return meterData.get(name) as UpDownCounter;
   }
 
   const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
 
-  switch (type) {
-    case MetricType.Counter:
-      const counter = meter.createCounter(name, options);
-      meterData.set(name, counter);
-      return counter;
-    case MetricType.UpDownCounter:
-      const upDownCounter = meter.createUpDownCounter(name, options);
-      meterData.set(name, upDownCounter);
-      return upDownCounter;
-    default:
-      throw new Error(`Unknown type: ${type}`);
+  const upDownCounter = meter.createUpDownCounter(name, options);
+  meterData.set(name, upDownCounter);
+  return upDownCounter;
+}
+
+export function getOrCreateObservableGauge(
+  name: string,
+  options: MetricOptions,
+  callback?: (observableResult: ObservableResult) => void,
+): ObservableGauge {
+  if (meterData.has(name)) {
+    return meterData.get(name) as ObservableGauge;
   }
+
+  const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
+
+  const observableGauge = meter.createObservableGauge(name, options, callback);
+  meterData.set(name, observableGauge);
+  return observableGauge;
+}
+
+export function getOrCreateObservableCounter(
+  name: string,
+  options: MetricOptions,
+  callback?: (observableResult: ObservableResult) => void,
+): ObservableCounter {
+  if (meterData.has(name)) {
+    return meterData.get(name) as ObservableCounter;
+  }
+
+  const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
+
+  const observableCounter = meter.createObservableCounter(name, options, callback);
+  meterData.set(name, observableCounter);
+  return observableCounter;
+}
+
+export function getOrCreateObservableUpDownCounter(
+  name: string,
+  options: MetricOptions,
+  callback?: (observableResult: ObservableResult) => void,
+): ObservableUpDownCounter {
+  if (meterData.has(name)) {
+    return meterData.get(name) as ObservableUpDownCounter;
+  }
+
+  const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
+
+  const observableCounter = meter.createObservableCounter(name, options, callback);
+  meterData.set(name, observableCounter);
+  return observableCounter;
 }

package/src/metrics/metric.service.ts

@@ -1,34 +1,48 @@
 import { Injectable } from '@nestjs/common';
 import {
-  Counter, UpDownCounter, ValueRecorder, MetricOptions,
+  MetricOptions, ObservableResult,
 } from '@opentelemetry/api-metrics';
 import {
-  getOrCreateCounter, getOrCreateValueRecorder, MetricType,
+  getOrCreateCounter, getOrCreateHistogram,
+  getOrCreateObservableCounter, getOrCreateObservableGauge,
+  getOrCreateObservableUpDownCounter, getOrCreateUpDownCounter,
 } from './metric-data';
 
 @Injectable()
 export class MetricService {
   getCounter(name: string, options?: MetricOptions) {
-    return this.getOrCreateCounter(name, MetricType.Counter, options);
+    return getOrCreateCounter(name, options);
   }
 
   getUpDownCounter(name: string, options?: MetricOptions) {
-    return this.getOrCreateCounter(name, MetricType.UpDownCounter, options);
+    return getOrCreateUpDownCounter(name, options);
   }
 
-  getValueRecorder(name: string, options?: MetricOptions) {
-    return this.getOrCreateValueRecorder(name, MetricType.ValueRecorder, options);
+  getHistogram(name: string, options?: MetricOptions) {
+    return getOrCreateHistogram(name, options);
   }
 
-  private getOrCreateValueRecorder(
-    name: string, type: MetricType, options: MetricOptions,
-  ): ValueRecorder {
-    return getOrCreateValueRecorder(name, type, options);
+  getObservableCounter(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observableResult: ObservableResult) => void,
+  ) {
+    return getOrCreateObservableCounter(name, options, callback);
   }
 
-  private getOrCreateCounter(
-    name: string, type: MetricType, options: MetricOptions,
-  ): Counter | UpDownCounter {
-    return getOrCreateCounter(name, type, options);
+  getObservableGauge(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observableResult: ObservableResult) => void,
+  ) {
+    return getOrCreateObservableGauge(name, options, callback);
+  }
+
+  getObservableUpDownCounter(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observableResult: ObservableResult) => void,
+  ) {
+    return getOrCreateObservableUpDownCounter(name, options, callback);
   }
 }

package/src/middleware/api-metrics.middleware.ts

@@ -1,7 +1,7 @@
 import { Inject, Injectable, NestMiddleware } from '@nestjs/common';
 import * as responseTime from 'response-time';
 import * as urlParser from 'url';
-import { Counter, Labels, ValueRecorder } from '@opentelemetry/api-metrics';
+import { Counter, Attributes, Histogram } from '@opentelemetry/api-metrics';
 import { OpenTelemetryModuleOptions } from '../interfaces';
 import { MetricService } from '../metrics/metric.service';
 import { OPENTELEMETRY_MODULE_OPTIONS } from '../opentelemetry.constants';
@@ -37,19 +37,19 @@ export class ApiMetricsMiddleware implements NestMiddleware {
 
   private serverAbortsTotal: Counter;
 
-  private requestDuration: ValueRecorder;
+  private requestDuration: Histogram;
 
-  private requestSizeValueRecorder: ValueRecorder;
+  private requestSizeHistogram: Histogram;
 
-  private responseSizeValueRecorder: ValueRecorder;
+  private responseSizeHistogram: Histogram;
 
-  private defaultLabels: Labels;
+  private defaultAttributes: Attributes;
 
   private readonly ignoreUndefinedRoutes: boolean;
 
   constructor(
-    @Inject(OPENTELEMETRY_MODULE_OPTIONS) private readonly options: OpenTelemetryModuleOptions = {},
     @Inject(MetricService) private readonly metricService: MetricService,
+    @Inject(OPENTELEMETRY_MODULE_OPTIONS) private readonly options: OpenTelemetryModuleOptions = {},
   ) {
     this.requestTotal = this.metricService.getCounter('http_request_total', {
       description: 'Total number of HTTP requests',
@@ -80,25 +80,25 @@ export class ApiMetricsMiddleware implements NestMiddleware {
     });
 
     const {
-      timeBuckets = [], requestSizeBuckets = [], responseSizeBuckets = [], defaultLabels = {},
+      timeBuckets = [], requestSizeBuckets = [], responseSizeBuckets = [], defaultAttributes = {},
       ignoreUndefinedRoutes = false,
     } = options?.metrics?.apiMetrics;
 
-    this.defaultLabels = defaultLabels;
+    this.defaultAttributes = defaultAttributes;
     this.ignoreUndefinedRoutes = ignoreUndefinedRoutes;
 
-    this.requestDuration = this.metricService.getValueRecorder('http_request_duration_seconds', {
+    this.requestDuration = this.metricService.getHistogram('http_request_duration_seconds', {
       boundaries: timeBuckets.length > 0 ? timeBuckets : this.defaultLongRunningRequestBuckets,
       description: 'HTTP latency value recorder in seconds',
     });
 
-    this.requestSizeValueRecorder = this.metricService.getValueRecorder('http_request_size_bytes', {
+    this.requestSizeHistogram = this.metricService.getHistogram('http_request_size_bytes', {
       boundaries:
         requestSizeBuckets.length > 0 ? requestSizeBuckets : this.defaultRequestSizeBuckets,
       description: 'Current total of incoming bytes',
     });
 
-    this.responseSizeValueRecorder = this.metricService.getValueRecorder('http_response_size_bytes', {
+    this.responseSizeHistogram = this.metricService.getHistogram('http_response_size_bytes', {
       boundaries:
         responseSizeBuckets.length > 0 ? responseSizeBuckets : this.defaultResponseSizeBuckets,
       description: 'Current total of outgoing bytes',
@@ -119,21 +119,21 @@ export class ApiMetricsMiddleware implements NestMiddleware {
         path = urlParser.parse(url).pathname;
       }
 
-      this.requestTotal.bind({ method, path }).add(1);
+      this.requestTotal.add(1, { method, path });
 
       const requestLength = parseInt(req.headers['content-length'], 10) || 0;
       const responseLength: number = parseInt(res.getHeader('Content-Length'), 10) || 0;
 
       const status = res.statusCode || 500;
-      const labels: Labels = {
-        method, status, path, ...this.defaultLabels,
+      const attributes: Attributes = {
+        method, status, path, ...this.defaultAttributes,
       };
 
-      this.requestSizeValueRecorder.bind(labels).record(requestLength);
-      this.responseSizeValueRecorder.bind(labels).record(responseLength);
+      this.requestSizeHistogram.record(requestLength, attributes);
+      this.responseSizeHistogram.record(responseLength, attributes);
 
-      this.responseTotal.bind(labels).add(1);
-      this.requestDuration.bind(labels).record(time / 1000);
+      this.responseTotal.add(1, attributes);
+      this.requestDuration.record(time / 1000, attributes);
 
       const codeClass = this.getStatusCodeClass(status);
 
@@ -143,7 +143,7 @@ export class ApiMetricsMiddleware implements NestMiddleware {
           this.responseSuccessTotal.add(1);
           break;
         case 'redirect':
-        // TODO: Review what should be appropriate for redirects.
+          // TODO: Review what should be appropriate for redirects.
           this.responseSuccessTotal.add(1);
           break;
         case 'client_error':

package/src/opentelemetry-core.module.ts

@@ -27,7 +27,7 @@ export class OpenTelemetryCoreModule implements OnApplicationBootstrap {
 
   constructor(
     @Inject(OPENTELEMETRY_MODULE_OPTIONS) private readonly options: OpenTelemetryModuleOptions = {},
-  ) {}
+  ) { }
 
   /**
    * Bootstraps the internal OpenTelemetry Module with the given options
@@ -93,8 +93,8 @@ export class OpenTelemetryCoreModule implements OnApplicationBootstrap {
   }
 
   async onApplicationBootstrap() {
-    let defaultMetrics:boolean = false;
-    let hostMetrics:boolean = false;
+    let defaultMetrics: boolean = false;
+    let hostMetrics: boolean = false;
 
     if (this.options?.metrics) {
       defaultMetrics = this.options.metrics.defaultMetrics

package/src/tracing/decorators/span.spec.ts

@@ -0,0 +1,48 @@
+import { context, trace } from '@opentelemetry/api';
+import { NodeSDK, tracing } from '@opentelemetry/sdk-node';
+import { Span } from './span';
+
+class TestSpan {
+  @Span()
+  singleSpan() {
+    return trace.getSpan(context.active());
+  }
+
+  @Span()
+  doubleSpan() {
+    return this.singleSpan();
+  }
+}
+
+describe('Span', () => {
+  let instance: TestSpan;
+  let otelSdk: NodeSDK;
+
+  beforeEach(async () => {
+    instance = new TestSpan();
+
+    otelSdk = new NodeSDK({
+      traceExporter: new tracing.ConsoleSpanExporter(),
+      // Noop Span Processor disables any spans from being outputted
+      // by ConsoleSpanExporter.
+      // Remove it if you want to debug spans exported.
+      spanProcessor: new tracing.NoopSpanProcessor(),
+    });
+
+    await otelSdk.start();
+  });
+
+  afterEach(async () => {
+    await otelSdk.shutdown();
+  });
+
+  it('should set correct span', async () => {
+    const response = instance.singleSpan();
+    expect((response as any).name).toEqual('TestSpan.singleSpan');
+  });
+
+  it('should set correct span even when calling other method with Span decorator', async () => {
+    const response = instance.doubleSpan();
+    expect((response as any).name).toEqual('TestSpan.singleSpan');
+  });
+});

package/src/tracing/decorators/span.ts

@@ -1,21 +1,14 @@
-import { context, trace } from '@opentelemetry/api';
+import { trace } from '@opentelemetry/api';
 
 export function Span(name?: string) {
-  return (
-    target: any,
-    propertyKey: string,
-    propertyDescriptor: PropertyDescriptor,
-  ) => {
+  return (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => {
     const method = propertyDescriptor.value;
     // eslint-disable-next-line no-param-reassign
     propertyDescriptor.value = function PropertyDescriptor(...args: any[]) {
-      const currentSpan = trace.getSpan(context.active());
       const tracer = trace.getTracer('default');
+      const spanName = name || `${target.constructor.name}.${propertyKey}`;
 
-      return context.with(trace.setSpan(context.active(), currentSpan), () => {
-        const span = tracer.startSpan(
-          name || `${target.constructor.name}.${propertyKey}`,
-        );
+      return tracer.startActiveSpan(spanName, span => {
         if (method.constructor.name === 'AsyncFunction') {
           return method.apply(this, args).finally(() => {
             span.end();

package/src/tracing/trace.service.ts

@@ -3,12 +3,15 @@ import { Injectable } from '@nestjs/common';
 
 @Injectable()
 export class TraceService {
+  public getTracer() {
+    return trace.getTracer('default');
+  }
+
   public getSpan(): Span {
     return trace.getSpan(context.active());
   }
 
   public startSpan(name: string): Span {
-    const tracer = trace.getTracer('default');
-    return tracer.startSpan(name);
+    return this.getTracer().startSpan(name);
   }
 }

package/lib/metrics/decorators/value-recorder.d.ts

@@ -1 +0,0 @@
-export declare const OtelValueRecorder: (...dataOrPipes: (string | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;