nestjs-otel 3.0.0 → 3.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-otel",
-  "version": "3.0.0",
+  "version": "3.0.3",
   "description": "NestJS OpenTelemetry Library",
   "main": "lib/index.js",
   "typings": "lib/index",
@@ -36,9 +36,9 @@
   },
   "homepage": "https://github.com/pragmaticivan/nestjs-otel#readme",
   "dependencies": {
-    "@opentelemetry/host-metrics": "^0.27.0",
     "@opentelemetry/api": "^1.0.4",
     "@opentelemetry/api-metrics": "^0.27.0",
+    "@opentelemetry/host-metrics": "^0.27.0",
     "opentelemetry-node-metrics": "^1.1.0",
     "response-time": "^2.3.2"
   },
@@ -52,11 +52,13 @@
     "@nestjs/testing": "^8.2.4",
     "@opentelemetry/exporter-prometheus": "^0.27.0",
     "@opentelemetry/sdk-node": "^0.27.0",
+    "@opentelemetry/sdk-trace-node": "^1.0.1",
     "@types/jest": "^27.0.3",
     "@types/node": "^17.0.5",
     "@types/supertest": "^2.0.11",
     "@typescript-eslint/eslint-plugin": "5.8.1",
     "@typescript-eslint/parser": "5.8.1",
+    "ansi-regex": "",
     "eslint": "^8.5.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-airbnb-typescript": "^16.1.0",
@@ -69,8 +71,7 @@
     "rxjs": "^7.5.1",
     "supertest": "^6.1.6",
     "ts-jest": "^27.1.2",
-    "typescript": "4.5.4",
-    "ansi-regex": ""
+    "typescript": "4.5.4"
   },
   "peerDependencies": {
     "@nestjs/common": "^7.0.0 || ^8.0.0",
@@ -95,7 +96,7 @@
     "testEnvironment": "node"
   },
   "lint-staged": {
-    "*.{js,ts}": "eslint --cache --fix"
+    "!(examples/**/*)*.{js,ts}": "eslint --cache --fix"
   },
   "commitlint": {
     "extends": [

package/src/metrics/metric-data.ts

@@ -1,6 +1,6 @@
 import {
   Counter, MetricOptions, metrics, UpDownCounter,
-  Histogram, ObservableGauge, ObservableCounter, ObservableUpDownCounter,
+  Histogram, ObservableGauge, ObservableCounter, ObservableUpDownCounter, ObservableResult,
 } from '@opentelemetry/api-metrics';
 import { OTEL_METER_NAME } from '../opentelemetry.constants';
 
@@ -70,6 +70,7 @@ export function getOrCreateUpDownCounter(
 export function getOrCreateObservableGauge(
   name: string,
   options: MetricOptions,
+  callback?: (observableResult: ObservableResult) => void,
 ): ObservableGauge {
   if (meterData.has(name)) {
     return meterData.get(name) as ObservableGauge;
@@ -77,7 +78,7 @@ export function getOrCreateObservableGauge(
 
   const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
 
-  const observableGauge = meter.createObservableGauge(name, options);
+  const observableGauge = meter.createObservableGauge(name, options, callback);
   meterData.set(name, observableGauge);
   return observableGauge;
 }
@@ -85,6 +86,7 @@ export function getOrCreateObservableGauge(
 export function getOrCreateObservableCounter(
   name: string,
   options: MetricOptions,
+  callback?: (observableResult: ObservableResult) => void,
 ): ObservableCounter {
   if (meterData.has(name)) {
     return meterData.get(name) as ObservableCounter;
@@ -92,7 +94,7 @@ export function getOrCreateObservableCounter(
 
   const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
 
-  const observableCounter = meter.createObservableCounter(name, options);
+  const observableCounter = meter.createObservableCounter(name, options, callback);
   meterData.set(name, observableCounter);
   return observableCounter;
 }
@@ -100,6 +102,7 @@ export function getOrCreateObservableCounter(
 export function getOrCreateObservableUpDownCounter(
   name: string,
   options: MetricOptions,
+  callback?: (observableResult: ObservableResult) => void,
 ): ObservableUpDownCounter {
   if (meterData.has(name)) {
     return meterData.get(name) as ObservableUpDownCounter;
@@ -107,7 +110,7 @@ export function getOrCreateObservableUpDownCounter(
 
   const meter = metrics.getMeterProvider().getMeter(OTEL_METER_NAME);
 
-  const observableCounter = meter.createObservableCounter(name, options);
+  const observableCounter = meter.createObservableCounter(name, options, callback);
   meterData.set(name, observableCounter);
   return observableCounter;
 }

package/src/metrics/metric.service.ts

@@ -1,11 +1,11 @@
 import { Injectable } from '@nestjs/common';
 import {
-  MetricOptions,
+  MetricOptions, ObservableResult,
 } from '@opentelemetry/api-metrics';
 import {
   getOrCreateCounter, getOrCreateHistogram,
   getOrCreateObservableCounter, getOrCreateObservableGauge,
-  getOrCreateObservableUpDownCounter, getOrCreateUpDownCounter, MetricType,
+  getOrCreateObservableUpDownCounter, getOrCreateUpDownCounter,
 } from './metric-data';
 
 @Injectable()
@@ -22,15 +22,27 @@ export class MetricService {
     return getOrCreateHistogram(name, options);
   }
 
-  getObservableCounter(name: string, options?: MetricOptions) {
-    return getOrCreateObservableCounter(name, options);
+  getObservableCounter(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observableResult: ObservableResult) => void,
+  ) {
+    return getOrCreateObservableCounter(name, options, callback);
   }
 
-  getObservableGauge(name: string, options?: MetricOptions) {
-    return getOrCreateObservableGauge(name, options);
+  getObservableGauge(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observableResult: ObservableResult) => void,
+  ) {
+    return getOrCreateObservableGauge(name, options, callback);
   }
 
-  getObservableUpDownCounter(name: string, options?: MetricOptions) {
-    return getOrCreateObservableUpDownCounter(name, options);
+  getObservableUpDownCounter(
+    name: string,
+    options?: MetricOptions,
+    callback?: (observableResult: ObservableResult) => void,
+  ) {
+    return getOrCreateObservableUpDownCounter(name, options, callback);
   }
 }

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

@@ -0,0 +1,91 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { tracing } from '@opentelemetry/sdk-node';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { Span } from './span';
+
+class TestSpan {
+  @Span()
+  singleSpan() {}
+
+  @Span()
+  doubleSpan() {
+    return this.singleSpan();
+  }
+
+  @Span()
+  error() {
+    throw new Error('hello world');
+  }
+}
+
+describe('Span', () => {
+  let instance: TestSpan;
+  let traceExporter: tracing.InMemorySpanExporter;
+  let spanProcessor: tracing.SimpleSpanProcessor;
+  let provider: NodeTracerProvider;
+
+  beforeAll(async () => {
+    instance = new TestSpan();
+    traceExporter = new tracing.InMemorySpanExporter();
+    spanProcessor = new tracing.SimpleSpanProcessor(traceExporter);
+
+    provider = new NodeTracerProvider();
+    provider.addSpanProcessor(spanProcessor);
+    provider.register();
+  });
+
+  afterEach(async () => {
+    spanProcessor.forceFlush();
+    traceExporter.reset();
+  });
+
+  afterAll(async () => {
+    await provider.shutdown();
+  });
+
+  it('should set correct span', async () => {
+    instance.singleSpan();
+
+    const spans = traceExporter.getFinishedSpans();
+
+    expect(spans).toHaveLength(1);
+    expect(spans.map(span => span.name)).toEqual(['TestSpan.singleSpan']);
+  });
+
+  it('should set correct span even when calling other method with Span decorator', async () => {
+    instance.doubleSpan();
+
+    const spans = traceExporter.getFinishedSpans();
+
+    expect(spans).toHaveLength(2);
+    expect(spans.map(span => span.name)).toEqual(['TestSpan.singleSpan', 'TestSpan.doubleSpan']);
+  });
+
+  it('should propagate errors', () => {
+    expect(instance.error).toThrowError('hello world');
+  });
+
+  it('should set setStatus to ERROR and message to error message', async () => {
+    expect(instance.error).toThrowError('hello world');
+
+    const spans = traceExporter.getFinishedSpans();
+
+    expect(spans).toHaveLength(1);
+    expect(spans[0].status).toEqual({ code: SpanStatusCode.ERROR, message: 'hello world' });
+  });
+
+  it('should set recordException with error', () => {
+    expect(instance.error).toThrowError('hello world');
+
+    const spans = traceExporter.getFinishedSpans();
+
+    expect(spans).toHaveLength(1);
+    // Contain one exception event
+    expect(spans[0].events).toHaveLength(1);
+    expect(spans[0].events[0]).toEqual({
+      name: 'exception',
+      attributes: expect.anything(),
+      time: expect.anything(),
+    });
+  });
+});

package/src/tracing/decorators/span.ts

@@ -1,29 +1,41 @@
-import { context, trace } from '@opentelemetry/api';
+import { Span as ApiSpan, SpanStatusCode, trace } from '@opentelemetry/api';
+
+const recordException = (span: ApiSpan, error: any) => {
+  span.recordException(error);
+  span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+};
 
 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();
-          });
+          return method
+            .apply(this, args)
+            .catch(error => {
+              recordException(span, error);
+              // Throw error to propagate it further
+              throw error;
+            })
+            .finally(() => {
+              span.end();
+            });
+        }
+
+        try {
+          return method.apply(this, args);
+        } catch (error) {
+          recordException(span, error);
+          // Throw error to propagate it further
+          throw error;
+        } finally {
+          span.end();
         }
-        const result = method.apply(this, args);
-        span.end();
-        return result;
       });
     };
   };