nestjs-otel 5.1.5 → 6.1.0

package/README.md

@@ -25,10 +25,18 @@ Please read this [comprehensive whitepaper](https://github.com/cncf/tag-observab
 
 ![observability-signals](https://user-images.githubusercontent.com/24193764/121773601-55f86b80-cb53-11eb-8c8b-262a5aad781f.png)
 
+
+## Examples
+
+A full working examples are available. This includes a nestjs application fully integrated with prometheus, grafana, loki and tempo:
+
+- [nestjs-otel-prom-grafana-tempo](https://github.com/pragmaticivan/nestjs-otel-prom-grafana-tempo )
+
+
 ## Installation
 
 ```bash
-$ npm i nestjs-otel @opentelemetry/sdk-node --save
+npm i nestjs-otel @opentelemetry/sdk-node --save
 ```
 
 ## Setup
@@ -58,10 +66,9 @@ import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-ho
 import * as process from 'process';
 
 const otelSDK = new NodeSDK({
-  metricExporter: new PrometheusExporter({
+  metricReader: new PrometheusExporter({
     port: 8081,
   }),
-  metricInterval: 1000,
   spanProcessor: new BatchSpanProcessor(new JaegerExporter()),
   contextManager: new AsyncLocalStorageContextManager(),
   textMapPropagator: new CompositePropagator({
@@ -126,6 +133,7 @@ const OpenTelemetryModuleConfig = OpenTelemetryModule.forRoot({
       },
       ignoreRoutes: ['/favicon.ico'], // You can ignore specific routes (See https://docs.nestjs.com/middleware#excluding-routes for options)
       ignoreUndefinedRoutes: false, //Records metrics for all URLs, even undefined ones
+      prefix: 'my_prefix', // Add a custom prefix to all API metrics
     },
   },
 });
@@ -315,11 +323,6 @@ export const loggerOptions: LoggerOptions = {
 export const logger: Logger = Pino(loggerOptions);
 ```
 
-## Examples
-
-A full working examples are available. This includes a nestjs application fully integrated with prometheus, grafana, loki and tempo:
-
-* [nestjs-otel-prom-grafana-tempo](https://github.com/pragmaticivan/nestjs-otel-prom-grafana-tempo )
 ## Stargazers over time
 
 [![Stargazers over time](https://starchart.cc/pragmaticivan/nestjs-otel.svg)](https://starchart.cc/pragmaticivan/nestjs-otel)

package/lib/index.js

@@ -1,23 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./opentelemetry.module"), exports);
-__exportStar(require("./tracing/decorators/span"), exports);
-__exportStar(require("./tracing/trace.service"), exports);
-__exportStar(require("./metrics/metric.service"), exports);
-__exportStar(require("./metrics/injector"), exports);
-__exportStar(require("./metrics/decorators"), exports);
-__exportStar(require("./opentelemetry.constants"), exports);
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./opentelemetry.module"), exports);
+tslib_1.__exportStar(require("./tracing/decorators/span"), exports);
+tslib_1.__exportStar(require("./tracing/trace.service"), exports);
+tslib_1.__exportStar(require("./metrics/metric.service"), exports);
+tslib_1.__exportStar(require("./metrics/injector"), exports);
+tslib_1.__exportStar(require("./metrics/decorators"), exports);
+tslib_1.__exportStar(require("./opentelemetry.constants"), exports);

package/lib/interfaces/index.js

@@ -1,17 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./opentelemetry-options.interface"), exports);
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./opentelemetry-options.interface"), exports);

package/lib/interfaces/metric-options.interface.d.ts

@@ -0,0 +1,7 @@
+import { MetricOptions } from '@opentelemetry/api';
+export interface OtelMetricOptions extends MetricOptions {
+    /**
+     * A prefix to add to the name of the metric.
+     */
+    prefix?: string;
+}

package/lib/interfaces/metric-options.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/interfaces/opentelemetry-options.interface.d.ts

@@ -1,25 +1,49 @@
 import { ModuleMetadata, Type, Abstract } from '@nestjs/common';
-import { MetricAttributes } from '@opentelemetry/api';
+import { Attributes } from '@opentelemetry/api';
 import { RouteInfo } from '@nestjs/common/interfaces';
 export type OpenTelemetryModuleOptions = {
+    /**
+     * OpenTelemetry Metrics Setup
+     */
     metrics?: OpenTelemetryMetrics;
 };
 export interface OpenTelemetryOptionsFactory {
     createOpenTelemetryOptions(): Promise<OpenTelemetryModuleOptions> | OpenTelemetryModuleOptions;
 }
+/**
+ * The options for the asynchronous Terminus module creation
+ *
+ * @publicApi
+ */
 export interface OpenTelemetryModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * The name of the module
+     */
     name?: string;
+    /**
+     * The class which should be used to provide the Terminus options
+     */
     useClass?: Type<OpenTelemetryOptionsFactory>;
+    /**
+     * Import existing providers from other module
+     */
     useExisting?: Type<OpenTelemetryOptionsFactory>;
+    /**
+     * The factory which should be used to provide the Terminus options
+     */
     useFactory?: (...args: any[]) => Promise<OpenTelemetryModuleOptions> | OpenTelemetryModuleOptions;
+    /**
+     * The providers which should get injected
+     */
     inject?: (string | symbol | Function | Type<any> | Abstract<any>)[];
 }
 export type OpenTelemetryMetrics = {
     hostMetrics?: boolean;
     apiMetrics?: {
         enable?: boolean;
-        defaultAttributes?: MetricAttributes;
+        defaultAttributes?: Attributes;
         ignoreRoutes?: (string | RouteInfo)[];
         ignoreUndefinedRoutes?: boolean;
+        prefix?: string;
     };
 };

package/lib/metrics/decorators/common.d.ts

@@ -1,5 +1,13 @@
-import { MetricOptions } from '@opentelemetry/api';
-export declare const OtelInstanceCounter: (options?: MetricOptions) => <T extends new (...args: any[]) => {}>(originalClass: T) => {
+import { OtelMetricOptions } from '../../interfaces/metric-options.interface';
+/**
+ * Create and increment a counter when a new instance is created
+ *
+ * @param originalClass
+ */
+export declare const OtelInstanceCounter: (options?: OtelMetricOptions) => <T extends new (...args: any[]) => {}>(originalClass: T) => {
     new (...args: any[]): {};
 } & T;
-export declare const OtelMethodCounter: (options?: MetricOptions) => (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => any>) => void;
+/**
+ * Create and increment a counter when the method is called
+ */
+export declare const OtelMethodCounter: (options?: OtelMetricOptions) => (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => any>) => void;

package/lib/metrics/decorators/common.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OtelMethodCounter = exports.OtelInstanceCounter = void 0;
 const opentelemetry_utils_1 = require("../../opentelemetry.utils");
 const metric_data_1 = require("../metric-data");
+/**
+ * Create and increment a counter when a new instance is created
+ *
+ * @param originalClass
+ */
 const OtelInstanceCounter = (options) => (originalClass) => {
     const name = `app_${originalClass.name}_instances_total`;
     const description = `app_${originalClass.name} object instances total`;
@@ -20,6 +25,9 @@ const OtelInstanceCounter = (options) => (originalClass) => {
     return wrappedClass;
 };
 exports.OtelInstanceCounter = OtelInstanceCounter;
+/**
+ * Create and increment a counter when the method is called
+ */
 const OtelMethodCounter = (options) => (target, propertyKey, descriptor) => {
     const className = target.constructor.name;
     const name = `app_${className}_${propertyKey.toString()}_calls_total`;
@@ -31,6 +39,7 @@ const OtelMethodCounter = (options) => (target, propertyKey, descriptor) => {
             counterMetric = (0, metric_data_1.getOrCreateCounter)(name, { description, ...options });
         }
         counterMetric.add(1);
+        // @ts-ignore
         return originalFunction.apply(this, args);
     };
     descriptor.value = wrappedFunction;

package/lib/metrics/decorators/common.spec.js

@@ -1,14 +1,6 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 require("reflect-metadata");
 const common_1 = require("@nestjs/common");
 const common_2 = require("./common");
@@ -16,14 +8,14 @@ const TestDecoratorThatSetsMetadata = () => (0, common_1.SetMetadata)('some-meta
 let TestClass = class TestClass {
     method() { }
 };
-__decorate([
+tslib_1.__decorate([
     TestDecoratorThatSetsMetadata(),
     (0, common_2.OtelMethodCounter)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
 ], TestClass.prototype, "method", null);
-TestClass = __decorate([
+TestClass = tslib_1.__decorate([
     (0, common_2.OtelInstanceCounter)(),
     TestDecoratorThatSetsMetadata()
 ], TestClass);

package/lib/metrics/decorators/index.js

@@ -1,20 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./common"), exports);
-__exportStar(require("./counter"), exports);
-__exportStar(require("./histogram"), exports);
-__exportStar(require("./observable"), exports);
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./common"), exports);
+tslib_1.__exportStar(require("./counter"), exports);
+tslib_1.__exportStar(require("./histogram"), exports);
+tslib_1.__exportStar(require("./observable"), exports);

package/lib/metrics/metric-data.d.ts

@@ -1,4 +1,5 @@
-import { Counter, MetricOptions, UpDownCounter, Histogram, ObservableGauge, ObservableCounter, ObservableUpDownCounter } from '@opentelemetry/api';
+import { Counter, UpDownCounter, Histogram, ObservableGauge, ObservableCounter, ObservableUpDownCounter } from '@opentelemetry/api';
+import { OtelMetricOptions } from '../interfaces/metric-options.interface';
 export type GenericMetric = Counter | UpDownCounter | Histogram | ObservableGauge | ObservableCounter | ObservableUpDownCounter;
 export declare enum MetricType {
     'Counter' = "Counter",
@@ -9,9 +10,9 @@ export declare enum MetricType {
     'ObservableUpDownCounter' = "ObservableUpDownCounter"
 }
 export declare const meterData: Map<string, GenericMetric>;
-export declare function getOrCreateHistogram(name: string, options?: MetricOptions): Histogram;
-export declare function getOrCreateCounter(name: string, options?: MetricOptions): Counter;
-export declare function getOrCreateUpDownCounter(name: string, options?: MetricOptions): UpDownCounter;
-export declare function getOrCreateObservableGauge(name: string, options?: MetricOptions): ObservableGauge;
-export declare function getOrCreateObservableCounter(name: string, options?: MetricOptions): ObservableCounter;
-export declare function getOrCreateObservableUpDownCounter(name: string, options?: MetricOptions): ObservableUpDownCounter;
+export declare function getOrCreateHistogram(name: string, options?: OtelMetricOptions): Histogram;
+export declare function getOrCreateCounter(name: string, options?: OtelMetricOptions): Counter;
+export declare function getOrCreateUpDownCounter(name: string, options?: OtelMetricOptions): UpDownCounter;
+export declare function getOrCreateObservableGauge(name: string, options?: OtelMetricOptions): ObservableGauge;
+export declare function getOrCreateObservableCounter(name: string, options?: OtelMetricOptions): ObservableCounter;
+export declare function getOrCreateObservableUpDownCounter(name: string, options?: OtelMetricOptions): ObservableUpDownCounter;

package/lib/metrics/metric-data.js

@@ -13,63 +13,37 @@ var MetricType;
     MetricType["ObservableUpDownCounter"] = "ObservableUpDownCounter";
 })(MetricType || (exports.MetricType = MetricType = {}));
 exports.meterData = new Map();
-function getOrCreateHistogram(name, options = {}) {
-    if (exports.meterData.has(name)) {
-        return exports.meterData.get(name);
+function getOrCreate(name, options = {}, type) {
+    const nameWithPrefix = options.prefix ? `${options.prefix}.${name}` : name;
+    let metric = exports.meterData.get(nameWithPrefix);
+    if (metric === undefined) {
+        const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
+        metric = meter[`create${type}`](nameWithPrefix, options);
+        exports.meterData.set(nameWithPrefix, metric);
     }
-    const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
-    const histogram = meter.createHistogram(name, options);
-    exports.meterData.set(name, histogram);
-    return histogram;
+    return metric;
+}
+function getOrCreateHistogram(name, options = {}) {
+    return getOrCreate(name, options, MetricType.Histogram);
 }
 exports.getOrCreateHistogram = getOrCreateHistogram;
 function getOrCreateCounter(name, options = {}) {
-    if (exports.meterData.has(name)) {
-        return exports.meterData.get(name);
-    }
-    const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
-    const counter = meter.createCounter(name, options);
-    exports.meterData.set(name, counter);
-    return counter;
+    return getOrCreate(name, options, MetricType.Counter);
 }
 exports.getOrCreateCounter = getOrCreateCounter;
 function getOrCreateUpDownCounter(name, options = {}) {
-    if (exports.meterData.has(name)) {
-        return exports.meterData.get(name);
-    }
-    const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
-    const upDownCounter = meter.createUpDownCounter(name, options);
-    exports.meterData.set(name, upDownCounter);
-    return upDownCounter;
+    return getOrCreate(name, options, MetricType.UpDownCounter);
 }
 exports.getOrCreateUpDownCounter = getOrCreateUpDownCounter;
 function getOrCreateObservableGauge(name, options = {}) {
-    if (exports.meterData.has(name)) {
-        return exports.meterData.get(name);
-    }
-    const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
-    const observableGauge = meter.createObservableGauge(name, options);
-    exports.meterData.set(name, observableGauge);
-    return observableGauge;
+    return getOrCreate(name, options, MetricType.ObservableGauge);
 }
 exports.getOrCreateObservableGauge = getOrCreateObservableGauge;
 function getOrCreateObservableCounter(name, options = {}) {
-    if (exports.meterData.has(name)) {
-        return exports.meterData.get(name);
-    }
-    const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
-    const observableCounter = meter.createObservableCounter(name, options);
-    exports.meterData.set(name, observableCounter);
-    return observableCounter;
+    return getOrCreate(name, options, MetricType.ObservableCounter);
 }
 exports.getOrCreateObservableCounter = getOrCreateObservableCounter;
 function getOrCreateObservableUpDownCounter(name, options = {}) {
-    if (exports.meterData.has(name)) {
-        return exports.meterData.get(name);
-    }
-    const meter = api_1.metrics.getMeterProvider().getMeter(opentelemetry_constants_1.OTEL_METER_NAME);
-    const observableCounter = meter.createObservableCounter(name, options);
-    exports.meterData.set(name, observableCounter);
-    return observableCounter;
+    return getOrCreate(name, options, MetricType.ObservableUpDownCounter);
 }
 exports.getOrCreateObservableUpDownCounter = getOrCreateObservableUpDownCounter;

package/lib/metrics/metric.service.d.ts

@@ -1,9 +1,9 @@
-import { MetricOptions } from '@opentelemetry/api';
+import { OtelMetricOptions } from '../interfaces/metric-options.interface';
 export declare class MetricService {
-    getCounter(name: string, options?: MetricOptions): import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
-    getUpDownCounter(name: string, options?: MetricOptions): import("@opentelemetry/api").UpDownCounter<import("@opentelemetry/api").Attributes>;
-    getHistogram(name: string, options?: MetricOptions): import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
-    getObservableCounter(name: string, options?: MetricOptions): import("@opentelemetry/api").ObservableCounter;
-    getObservableGauge(name: string, options?: MetricOptions): import("@opentelemetry/api").ObservableGauge;
-    getObservableUpDownCounter(name: string, options?: MetricOptions): import("@opentelemetry/api").ObservableUpDownCounter;
+    getCounter(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").Counter<import("@opentelemetry/api").Attributes>;
+    getUpDownCounter(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").UpDownCounter<import("@opentelemetry/api").Attributes>;
+    getHistogram(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").Histogram<import("@opentelemetry/api").Attributes>;
+    getObservableCounter(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").ObservableCounter;
+    getObservableGauge(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").ObservableGauge;
+    getObservableUpDownCounter(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").ObservableUpDownCounter;
 }

package/lib/metrics/metric.service.js

@@ -1,15 +1,10 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetricService = void 0;
+const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const metric_data_1 = require("./metric-data");
-let MetricService = exports.MetricService = class MetricService {
+let MetricService = class MetricService {
     getCounter(name, options) {
         return (0, metric_data_1.getOrCreateCounter)(name, options);
     }
@@ -29,6 +24,7 @@ let MetricService = exports.MetricService = class MetricService {
         return (0, metric_data_1.getOrCreateObservableUpDownCounter)(name, options);
     }
 };
-exports.MetricService = MetricService = __decorate([
+exports.MetricService = MetricService;
+exports.MetricService = MetricService = tslib_1.__decorate([
     (0, common_1.Injectable)()
 ], MetricService);

package/lib/metrics/utils.d.ts

@@ -1 +1,4 @@
+/**
+ * @public
+ */
 export declare function getToken(name: string): string;

package/lib/metrics/utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getToken = void 0;
+/**
+ * @public
+ */
 function getToken(name) {
     return `OTEL_METRIC_${name.toUpperCase()}`;
 }

package/lib/middleware/api-metrics.middleware.d.ts

@@ -4,7 +4,7 @@ import { MetricService } from '../metrics/metric.service';
 export declare class ApiMetricsMiddleware implements NestMiddleware {
     private readonly metricService;
     private readonly options;
-    private defaultMetricAttributes;
+    private defaultAttributes;
     private httpServerRequestCount;
     private httpServerResponseCount;
     private httpServerDuration;

package/lib/middleware/api-metrics.middleware.js

@@ -1,67 +1,67 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiMetricsMiddleware = void 0;
+const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
-const responseTime = require("response-time");
-const urlParser = require("url");
+const response_time_1 = tslib_1.__importDefault(require("response-time"));
+const urlParser = tslib_1.__importStar(require("url"));
 const metric_service_1 = require("../metrics/metric.service");
 const opentelemetry_constants_1 = require("../opentelemetry.constants");
-let ApiMetricsMiddleware = exports.ApiMetricsMiddleware = class ApiMetricsMiddleware {
+let ApiMetricsMiddleware = class ApiMetricsMiddleware {
     constructor(metricService, options = {}) {
         this.metricService = metricService;
         this.options = options;
-        const { defaultAttributes = {}, ignoreUndefinedRoutes = false, } = options?.metrics?.apiMetrics ?? {};
-        this.defaultMetricAttributes = defaultAttributes;
+        const { defaultAttributes = {}, ignoreUndefinedRoutes = false, prefix, } = options?.metrics?.apiMetrics ?? {};
+        this.defaultAttributes = defaultAttributes;
         this.ignoreUndefinedRoutes = ignoreUndefinedRoutes;
+        // Semantic Convention
         this.httpServerRequestCount = this.metricService.getCounter('http.server.request.count', {
             description: 'Total number of HTTP requests',
             unit: 'requests',
+            prefix,
         });
         this.httpServerResponseCount = this.metricService.getCounter('http.server.response.count', {
             description: 'Total number of HTTP responses',
             unit: 'responses',
+            prefix,
         });
         this.httpServerAbortCount = this.metricService.getCounter('http.server.abort.count', {
             description: 'Total number of data transfers aborted',
             unit: 'requests',
+            prefix,
         });
         this.httpServerDuration = this.metricService.getHistogram('http.server.duration', {
             description: 'The duration of the inbound HTTP request',
             unit: 'ms',
+            prefix,
         });
         this.httpServerRequestSize = this.metricService.getHistogram('http.server.request.size', {
             description: 'Size of incoming bytes',
             unit: 'By',
+            prefix,
         });
         this.httpServerResponseSize = this.metricService.getHistogram('http.server.response.size', {
             description: 'Size of outgoing bytes',
             unit: 'By',
+            prefix,
         });
+        // Helpers
         this.httpServerResponseSuccessCount = this.metricService.getCounter('http.server.response.success.count', {
             description: 'Total number of all successful responses',
             unit: 'responses',
+            prefix,
         });
         this.httpServerResponseErrorCount = this.metricService.getCounter('http.server.response.error.count', {
             description: 'Total number of all response errors',
+            prefix,
         });
         this.httpClientRequestErrorCount = this.metricService.getCounter('http.client.request.error.count', {
             description: 'Total number of client error requests',
+            prefix,
         });
     }
     use(req, res, next) {
-        responseTime((req, res, time) => {
+        (0, response_time_1.default)((req, res, time) => {
             const { route, url, method } = req;
             let path;
             if (route) {
@@ -78,7 +78,10 @@ let ApiMetricsMiddleware = exports.ApiMetricsMiddleware = class ApiMetricsMiddle
             const responseLength = parseInt(res.getHeader('Content-Length'), 10) || 0;
             const status = res.statusCode || 500;
             const attributes = {
-                method, status, path, ...this.defaultMetricAttributes,
+                method,
+                status,
+                path,
+                ...this.defaultAttributes,
             };
             this.httpServerRequestSize.record(requestLength, attributes);
             this.httpServerResponseSize.record(responseLength, attributes);
@@ -90,6 +93,7 @@ let ApiMetricsMiddleware = exports.ApiMetricsMiddleware = class ApiMetricsMiddle
                     this.httpServerResponseSuccessCount.add(1);
                     break;
                 case 'redirect':
+                    // TODO: Review what should be appropriate for redirects.
                     this.httpServerResponseSuccessCount.add(1);
                     break;
                 case 'client_error':
@@ -118,9 +122,10 @@ let ApiMetricsMiddleware = exports.ApiMetricsMiddleware = class ApiMetricsMiddle
         return 'server_error';
     }
 };
-exports.ApiMetricsMiddleware = ApiMetricsMiddleware = __decorate([
+exports.ApiMetricsMiddleware = ApiMetricsMiddleware;
+exports.ApiMetricsMiddleware = ApiMetricsMiddleware = tslib_1.__decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, common_1.Inject)(metric_service_1.MetricService)),
-    __param(1, (0, common_1.Inject)(opentelemetry_constants_1.OPENTELEMETRY_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [metric_service_1.MetricService, Object])
+    tslib_1.__param(0, (0, common_1.Inject)(metric_service_1.MetricService)),
+    tslib_1.__param(1, (0, common_1.Inject)(opentelemetry_constants_1.OPENTELEMETRY_MODULE_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [metric_service_1.MetricService, Object])
 ], ApiMetricsMiddleware);

package/lib/middleware/index.js

@@ -1,17 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./api-metrics.middleware"), exports);
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./api-metrics.middleware"), exports);

package/lib/opentelemetry-core.module.d.ts

@@ -1,13 +1,39 @@
 import { DynamicModule, MiddlewareConsumer, OnApplicationBootstrap } from '@nestjs/common';
 import { OpenTelemetryModuleAsyncOptions, OpenTelemetryModuleOptions } from './interfaces';
+/**
+ * The internal OpenTelemetry Module which handles the integration
+ * with the third party OpenTelemetry library and Nest
+ *
+ * @internal
+ */
 export declare class OpenTelemetryCoreModule implements OnApplicationBootstrap {
     private readonly options;
     private readonly logger;
     constructor(options?: OpenTelemetryModuleOptions);
+    /**
+     * Bootstraps the internal OpenTelemetry Module with the given options
+     * synchronously and sets the correct providers
+     * @param options The options to bootstrap the module synchronously
+     */
     static forRoot(options?: OpenTelemetryModuleOptions): DynamicModule;
+    /**
+     * Bootstraps the internal OpenTelemetry Module with the given
+     * options asynchronously and sets the correct providers
+     * @param options The options to bootstrap the module
+     */
     static forRootAsync(options: OpenTelemetryModuleAsyncOptions): DynamicModule;
     configure(consumer: MiddlewareConsumer): void;
     onApplicationBootstrap(): Promise<void>;
+    /**
+     * Returns the asynchrnous OpenTelemetry options providers depending on the
+     * given module options
+     * @param options Options for the asynchrnous OpenTelemetry module
+     */
     private static createAsyncOptionsProvider;
+    /**
+     * Returns the asynchrnous providers depending on the given module
+     * options
+     * @param options Options for the asynchrnous OpenTelemetry module
+     */
     private static createAsyncProviders;
 }

package/lib/opentelemetry-core.module.js

@@ -1,19 +1,8 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 var OpenTelemetryCoreModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenTelemetryCoreModule = void 0;
+const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const host_metrics_1 = require("@opentelemetry/host-metrics");
 const api_1 = require("@opentelemetry/api");
@@ -21,11 +10,22 @@ const metric_service_1 = require("./metrics/metric.service");
 const middleware_1 = require("./middleware");
 const opentelemetry_constants_1 = require("./opentelemetry.constants");
 const trace_service_1 = require("./tracing/trace.service");
-let OpenTelemetryCoreModule = exports.OpenTelemetryCoreModule = OpenTelemetryCoreModule_1 = class OpenTelemetryCoreModule {
+/**
+ * The internal OpenTelemetry Module which handles the integration
+ * with the third party OpenTelemetry library and Nest
+ *
+ * @internal
+ */
+let OpenTelemetryCoreModule = OpenTelemetryCoreModule_1 = class OpenTelemetryCoreModule {
     constructor(options = {}) {
         this.options = options;
         this.logger = new common_1.Logger('OpenTelemetryModule');
     }
+    /**
+     * Bootstraps the internal OpenTelemetry Module with the given options
+     * synchronously and sets the correct providers
+     * @param options The options to bootstrap the module synchronously
+     */
     static forRoot(options = {}) {
         const openTelemetryModuleOptions = {
             provide: opentelemetry_constants_1.OPENTELEMETRY_MODULE_OPTIONS,
@@ -33,38 +33,32 @@ let OpenTelemetryCoreModule = exports.OpenTelemetryCoreModule = OpenTelemetryCor
         };
         return {
             module: OpenTelemetryCoreModule_1,
-            providers: [
-                openTelemetryModuleOptions,
-                trace_service_1.TraceService,
-                metric_service_1.MetricService,
-            ],
-            exports: [
-                trace_service_1.TraceService,
-                metric_service_1.MetricService,
-            ],
+            providers: [openTelemetryModuleOptions, trace_service_1.TraceService, metric_service_1.MetricService],
+            exports: [trace_service_1.TraceService, metric_service_1.MetricService],
         };
     }
+    /**
+     * Bootstraps the internal OpenTelemetry Module with the given
+     * options asynchronously and sets the correct providers
+     * @param options The options to bootstrap the module
+     */
     static forRootAsync(options) {
         const asyncProviders = this.createAsyncProviders(options);
         return {
             module: OpenTelemetryCoreModule_1,
             imports: [...(options.imports || [])],
-            providers: [
-                ...asyncProviders,
-                trace_service_1.TraceService,
-                metric_service_1.MetricService,
-            ],
-            exports: [
-                trace_service_1.TraceService,
-                metric_service_1.MetricService,
-            ],
+            providers: [...asyncProviders, trace_service_1.TraceService, metric_service_1.MetricService],
+            exports: [trace_service_1.TraceService, metric_service_1.MetricService],
         };
     }
     configure(consumer) {
-        const { apiMetrics = { enable: false }, } = this.options?.metrics ?? {};
+        const { apiMetrics = { enable: false } } = this.options?.metrics ?? {};
         if (apiMetrics.enable === true) {
             if (apiMetrics?.ignoreRoutes && apiMetrics?.ignoreRoutes.length > 0) {
-                consumer.apply(middleware_1.ApiMetricsMiddleware).exclude(...apiMetrics.ignoreRoutes).forRoutes('*');
+                consumer
+                    .apply(middleware_1.ApiMetricsMiddleware)
+                    .exclude(...apiMetrics.ignoreRoutes)
+                    .forRoutes('*');
             }
             else {
                 consumer.apply(middleware_1.ApiMetricsMiddleware).forRoutes('*');
@@ -74,8 +68,8 @@ let OpenTelemetryCoreModule = exports.OpenTelemetryCoreModule = OpenTelemetryCor
     async onApplicationBootstrap() {
         let hostMetrics = false;
         if (this.options?.metrics) {
-            hostMetrics = this.options.metrics.hostMetrics
-                !== undefined ? this.options.metrics.hostMetrics : false;
+            hostMetrics =
+                this.options.metrics.hostMetrics !== undefined ? this.options.metrics.hostMetrics : false;
         }
         const meterProvider = api_1.metrics.getMeterProvider();
         if (hostMetrics) {
@@ -83,6 +77,11 @@ let OpenTelemetryCoreModule = exports.OpenTelemetryCoreModule = OpenTelemetryCor
             host.start();
         }
     }
+    /**
+     * Returns the asynchrnous OpenTelemetry options providers depending on the
+     * given module options
+     * @param options Options for the asynchrnous OpenTelemetry module
+     */
     static createAsyncOptionsProvider(options) {
         if (options.useFactory) {
             return {
@@ -103,6 +102,11 @@ let OpenTelemetryCoreModule = exports.OpenTelemetryCoreModule = OpenTelemetryCor
         }
         throw new Error();
     }
+    /**
+     * Returns the asynchrnous providers depending on the given module
+     * options
+     * @param options Options for the asynchrnous OpenTelemetry module
+     */
     static createAsyncProviders(options) {
         if (options.useFactory || options.useExisting) {
             return [this.createAsyncOptionsProvider(options)];
@@ -117,9 +121,10 @@ let OpenTelemetryCoreModule = exports.OpenTelemetryCoreModule = OpenTelemetryCor
         ];
     }
 };
-exports.OpenTelemetryCoreModule = OpenTelemetryCoreModule = OpenTelemetryCoreModule_1 = __decorate([
+exports.OpenTelemetryCoreModule = OpenTelemetryCoreModule;
+exports.OpenTelemetryCoreModule = OpenTelemetryCoreModule = OpenTelemetryCoreModule_1 = tslib_1.__decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({}),
-    __param(0, (0, common_1.Inject)(opentelemetry_constants_1.OPENTELEMETRY_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object])
+    tslib_1.__param(0, (0, common_1.Inject)(opentelemetry_constants_1.OPENTELEMETRY_MODULE_OPTIONS)),
+    tslib_1.__metadata("design:paramtypes", [Object])
 ], OpenTelemetryCoreModule);

package/lib/opentelemetry.module.d.ts

@@ -1,6 +1,20 @@
 import { DynamicModule } from '@nestjs/common';
 import { OpenTelemetryModuleAsyncOptions, OpenTelemetryModuleOptions } from './interfaces';
+/**
+ * The NestJS module for OpenTelemetry
+ *
+ * @publicApi
+ */
 export declare class OpenTelemetryModule {
+    /**
+     * Bootstraps the OpenTelemetry Module synchronously
+     * @param options The options for the OpenTelemetry Module
+     */
     static forRoot(options?: OpenTelemetryModuleOptions): DynamicModule;
+    /**
+     * Bootstrap the OpenTelemetry Module asynchronously
+     * @see https://dev.to/nestjs/advanced-nestjs-how-to-build-completely-dynamic-nestjs-modules-1370
+     * @param options The options for the OpenTelemetry module
+     */
     static forRootAsync(options: OpenTelemetryModuleAsyncOptions): DynamicModule;
 }

package/lib/opentelemetry.module.js

@@ -1,22 +1,31 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 var OpenTelemetryModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenTelemetryModule = void 0;
+const tslib_1 = require("tslib");
 const common_1 = require("@nestjs/common");
 const opentelemetry_core_module_1 = require("./opentelemetry-core.module");
-let OpenTelemetryModule = exports.OpenTelemetryModule = OpenTelemetryModule_1 = class OpenTelemetryModule {
+/**
+ * The NestJS module for OpenTelemetry
+ *
+ * @publicApi
+ */
+let OpenTelemetryModule = OpenTelemetryModule_1 = class OpenTelemetryModule {
+    /**
+     * Bootstraps the OpenTelemetry Module synchronously
+     * @param options The options for the OpenTelemetry Module
+     */
     static forRoot(options) {
         return {
             module: OpenTelemetryModule_1,
             imports: [opentelemetry_core_module_1.OpenTelemetryCoreModule.forRoot(options)],
         };
     }
+    /**
+     * Bootstrap the OpenTelemetry Module asynchronously
+     * @see https://dev.to/nestjs/advanced-nestjs-how-to-build-completely-dynamic-nestjs-modules-1370
+     * @param options The options for the OpenTelemetry module
+     */
     static forRootAsync(options) {
         return {
             module: OpenTelemetryModule_1,
@@ -24,6 +33,7 @@ let OpenTelemetryModule = exports.OpenTelemetryModule = OpenTelemetryModule_1 =
         };
     }
 };
-exports.OpenTelemetryModule = OpenTelemetryModule = OpenTelemetryModule_1 = __decorate([
+exports.OpenTelemetryModule = OpenTelemetryModule;
+exports.OpenTelemetryModule = OpenTelemetryModule = OpenTelemetryModule_1 = tslib_1.__decorate([
     (0, common_1.Module)({})
 ], OpenTelemetryModule);

package/lib/opentelemetry.utils.js

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.copyMetadataFromFunctionToFunction = void 0;
 const copyMetadataFromFunctionToFunction = (originalFunction, newFunction) => {
+    // Get the current metadata and set onto the wrapper
+    // to ensure other decorators ( ie: NestJS EventPattern / RolesGuard )
+    // won't be affected by the use of this instrumentation
     Reflect.getMetadataKeys(originalFunction).forEach(metadataKey => {
         Reflect.defineMetadata(metadataKey, Reflect.getMetadata(metadataKey, originalFunction), newFunction);
     });

package/lib/tracing/decorators/span.d.ts

@@ -1,2 +1,2 @@
 import { SpanOptions } from '@opentelemetry/api';
-export declare function Span(name?: string, options?: SpanOptions): (target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor) => void;
+export declare function Span(name?: string, options?: SpanOptions): (target: any, propertyKey: PropertyKey, propertyDescriptor: PropertyDescriptor) => void;

package/lib/tracing/decorators/span.js

@@ -12,24 +12,29 @@ function Span(name, options = {}) {
         const originalFunction = propertyDescriptor.value;
         const wrappedFunction = function PropertyDescriptor(...args) {
             const tracer = api_1.trace.getTracer('default');
-            const spanName = name || `${target.constructor.name}.${propertyKey}`;
+            const spanName = name || `${target.constructor.name}.${String(propertyKey)}`;
             return tracer.startActiveSpan(spanName, options, span => {
                 if (originalFunction.constructor.name === 'AsyncFunction') {
-                    return originalFunction
+                    return (originalFunction
+                        // @ts-ignore
                         .apply(this, args)
+                        // @ts-ignore
                         .catch(error => {
                         recordException(span, error);
+                        // Throw error to propagate it further
                         throw error;
                     })
                         .finally(() => {
                         span.end();
-                    });
+                    }));
                 }
                 try {
+                    // @ts-ignore
                     return originalFunction.apply(this, args);
                 }
                 catch (error) {
                     recordException(span, error);
+                    // Throw error to propagate it further
                     throw error;
                 }
                 finally {

package/lib/tracing/decorators/span.spec.js

@@ -1,20 +1,14 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 require("reflect-metadata");
 const api_1 = require("@opentelemetry/api");
 const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
 const common_1 = require("@nestjs/common");
 const span_1 = require("./span");
 const TestDecoratorThatSetsMetadata = () => (0, common_1.SetMetadata)('some-metadata', true);
+const symbol = Symbol('testSymbol');
 class TestSpan {
     singleSpan() { }
     doubleSpan() {
@@ -25,38 +19,45 @@ class TestSpan {
         throw new Error('hello world');
     }
     metadata() { }
+    [_a = symbol]() { }
 }
-__decorate([
+tslib_1.__decorate([
     (0, span_1.Span)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
 ], TestSpan.prototype, "singleSpan", null);
-__decorate([
+tslib_1.__decorate([
     (0, span_1.Span)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
 ], TestSpan.prototype, "doubleSpan", null);
-__decorate([
+tslib_1.__decorate([
     (0, span_1.Span)('foo', { kind: api_1.SpanKind.PRODUCER }),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
 ], TestSpan.prototype, "fooProducerSpan", null);
-__decorate([
+tslib_1.__decorate([
     (0, span_1.Span)(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
 ], TestSpan.prototype, "error", null);
-__decorate([
+tslib_1.__decorate([
     (0, span_1.Span)(),
     TestDecoratorThatSetsMetadata(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", void 0)
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
 ], TestSpan.prototype, "metadata", null);
+tslib_1.__decorate([
+    (0, span_1.Span)(),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", []),
+    tslib_1.__metadata("design:returntype", void 0)
+], TestSpan.prototype, _a, null);
 describe('Span', () => {
     let instance;
     let traceExporter;
@@ -111,6 +112,7 @@ describe('Span', () => {
         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',
@@ -119,4 +121,10 @@ describe('Span', () => {
             time: expect.anything(),
         });
     });
+    it('should handle symbols', () => {
+        instance[symbol]();
+        const spans = traceExporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans.map(span => span.name)).toEqual(['TestSpan.Symbol(testSymbol)']);
+    });
 });

package/lib/tracing/trace.service.js

@@ -1,15 +1,10 @@
 "use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraceService = void 0;
+const tslib_1 = require("tslib");
 const api_1 = require("@opentelemetry/api");
 const common_1 = require("@nestjs/common");
-let TraceService = exports.TraceService = class TraceService {
+let TraceService = class TraceService {
     getTracer() {
         return api_1.trace.getTracer('default');
     }
@@ -20,6 +15,7 @@ let TraceService = exports.TraceService = class TraceService {
         return this.getTracer().startSpan(name);
     }
 };
-exports.TraceService = TraceService = __decorate([
+exports.TraceService = TraceService;
+exports.TraceService = TraceService = tslib_1.__decorate([
     (0, common_1.Injectable)()
 ], TraceService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-otel",
-  "version": "5.1.5",
+  "version": "6.1.0",
   "description": "NestJS OpenTelemetry Library",
   "main": "lib/index.js",
   "typings": "lib/index",
@@ -8,8 +8,8 @@
     "prebuild": "rimraf lib",
     "prepare": "husky install",
     "build": "tsc",
-    "lint": "eslint . --ext .js,ts",
-    "format": "eslint . --ext .js,ts --fix",
+    "lint": "prettier --check ./**/*.{js,json,ts}",
+    "format": "prettier --write ./**/*.{js,json,ts}",
     "test": "npm run test:unit && npm run test:e2e",
     "test:coverage": "jest --coverage",
     "test:unit": "jest --passWithNoTests",
@@ -36,40 +36,36 @@
   },
   "homepage": "https://github.com/pragmaticivan/nestjs-otel#readme",
   "dependencies": {
-    "@opentelemetry/api": "^1.4.1",
-    "@opentelemetry/host-metrics": "^0.32.2",
+    "@opentelemetry/api": "^1.8.0",
+    "@opentelemetry/host-metrics": "^0.35.1",
     "response-time": "^2.3.2"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.6.6",
-    "@commitlint/config-conventional": "^17.6.6",
-    "@nestjs/common": "^10.0.5",
-    "@nestjs/core": "^10.0.5",
-    "@nestjs/platform-express": "^10.0.5",
-    "@nestjs/platform-fastify": "^10.0.5",
-    "@nestjs/testing": "^10.0.5",
-    "@opentelemetry/exporter-prometheus": "^0.40.0",
-    "@opentelemetry/sdk-metrics": "^1.14.0",
-    "@opentelemetry/sdk-trace-node": "^1.14.0",
-    "@types/jest": "^29.5.2",
-    "@types/node": "^20.3.3",
-    "@types/supertest": "^2.0.12",
-    "@typescript-eslint/eslint-plugin": "5.61.0",
-    "@typescript-eslint/parser": "5.61.0",
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@nestjs/common": "^10.3.8",
+    "@nestjs/core": "^10.3.8",
+    "@nestjs/platform-express": "^10.3.8",
+    "@nestjs/platform-fastify": "^10.3.8",
+    "@nestjs/testing": "^10.3.8",
+    "@opentelemetry/exporter-prometheus": "^0.51.1",
+    "@opentelemetry/sdk-metrics": "^1.24.1",
+    "@opentelemetry/sdk-trace-node": "^1.24.1",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.10",
+    "@types/response-time": "^2.3.8",
+    "@types/supertest": "^6.0.2",
     "ansi-regex": "",
-    "eslint": "^8.44.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-config-airbnb-typescript": "^17.0.0",
-    "eslint-plugin-import": "^2.27.5",
-    "husky": "^8.0.3",
-    "jest": "^29.6.0",
-    "lint-staged": "^13.2.3",
-    "reflect-metadata": "^0.1.13",
-    "rimraf": "^5.0.1",
+    "husky": "^9.0.11",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.2.2",
+    "prettier": "^3.2.5",
+    "reflect-metadata": "^0.2.2",
+    "rimraf": "^5.0.5",
     "rxjs": "^7.8.1",
-    "supertest": "^6.3.3",
-    "ts-jest": "^29.1.1",
-    "typescript": "5.1.6"
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "5.4.5"
   },
   "peerDependencies": {
     "@nestjs/common": "^9.0.0 || ^10.0.0",
@@ -94,7 +90,9 @@
     "testEnvironment": "node"
   },
   "lint-staged": {
-    "!(examples/**/*)*.{js,ts}": "eslint --cache --fix"
+    "**/*.{js,ts,json}": [
+      "prettier --write"
+    ]
   },
   "commitlint": {
     "extends": [