nestjs-otel 8.0.0 → 8.0.2

package/README.md

@@ -1,6 +1,5 @@
 ![nestjs-otel](https://github.com/pragmaticivan/nestjs-otel/assets/301291/40aaad82-82f9-48e5-b204-0e3cef532813)
 
-
 # NestJS OpenTelemetry (OTEL)
 
 ![Build Status](https://github.com/pragmaticivan/nestjs-otel/actions/workflows/nodejs.yml/badge.svg)

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./interfaces";
+export * from "./metrics/decorators";
+export * from "./metrics/injector";
+export * from "./metrics/metric.service";
+export * from "./opentelemetry.constants";
+export * from "./opentelemetry.module";
+export * from "./tracing/decorators/baggage";
+export * from "./tracing/decorators/current-span";
+export * from "./tracing/decorators/span";
+export * from "./tracing/decorators/traceable";
+export * from "./tracing/trace.service";

package/lib/index.js

@@ -0,0 +1,27 @@
+"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("./interfaces"), exports);
+__exportStar(require("./metrics/decorators"), exports);
+__exportStar(require("./metrics/injector"), exports);
+__exportStar(require("./metrics/metric.service"), exports);
+__exportStar(require("./opentelemetry.constants"), exports);
+__exportStar(require("./opentelemetry.module"), exports);
+__exportStar(require("./tracing/decorators/baggage"), exports);
+__exportStar(require("./tracing/decorators/current-span"), exports);
+__exportStar(require("./tracing/decorators/span"), exports);
+__exportStar(require("./tracing/decorators/traceable"), exports);
+__exportStar(require("./tracing/trace.service"), exports);

package/lib/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./metric-options.interface";
+export * from "./opentelemetry-options.interface";

package/lib/interfaces/index.js

@@ -0,0 +1,18 @@
+"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("./metric-options.interface"), exports);
+__exportStar(require("./opentelemetry-options.interface"), exports);

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

@@ -0,0 +1,7 @@
+import type { 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

@@ -0,0 +1,40 @@
+import type { Abstract, ModuleMetadata, Type } from "@nestjs/common";
+export type OpenTelemetryModuleOptions = {
+    /**
+     * OpenTelemetry Metrics Setup
+     */
+    metrics?: OpenTelemetryMetrics;
+};
+export type OpenTelemetryOptionsFactory = {
+    createOpenTelemetryOptions(): Promise<OpenTelemetryModuleOptions> | OpenTelemetryModuleOptions;
+};
+/**
+ * The options for the asynchronous OpenTelemetry 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 OpenTelemetry options
+     */
+    useClass?: Type<OpenTelemetryOptionsFactory>;
+    /**
+     * Import existing providers from other module
+     */
+    useExisting?: Type<OpenTelemetryOptionsFactory>;
+    /**
+     * The factory which should be used to provide the OpenTelemetry 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;
+};

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

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

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

@@ -0,0 +1,19 @@
+import type { 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 & {
+    name?: string;
+}) => <T extends {
+    new (...args: any[]): {};
+}>(originalClass: T) => {
+    new (...args: any[]): {};
+} & T;
+/**
+ * Create and increment a counter when the method is called
+ */
+export declare const OtelMethodCounter: (options?: OtelMetricOptions & {
+    name?: string;
+}) => (target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => any>) => void;

package/lib/metrics/decorators/common.js

@@ -0,0 +1,55 @@
+"use strict";
+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 = options?.name || `app.${originalClass.name}.instances.total`;
+    const description = options?.description ||
+        `app.${originalClass.name} object instances total`;
+    let counterMetric;
+    const wrappedClass = class extends originalClass {
+        constructor(...args) {
+            if (!counterMetric) {
+                counterMetric = (0, metric_data_1.getOrCreateCounter)(name, { description, ...options });
+            }
+            counterMetric.add(1);
+            super(...args);
+        }
+    };
+    Object.defineProperty(wrappedClass, "name", { value: originalClass.name });
+    (0, opentelemetry_utils_1.copyMetadataFromFunctionToFunction)(originalClass, wrappedClass);
+    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 = options?.name || `app.${className}.${propertyKey.toString()}.calls.total`;
+    const description = options?.description ||
+        `app.${className}#${propertyKey.toString()} called total`;
+    let counterMetric;
+    const originalFunction = descriptor.value;
+    if (!originalFunction) {
+        return;
+    }
+    const wrappedFunction = function PropertyDescriptor(...args) {
+        if (!counterMetric) {
+            counterMetric = (0, metric_data_1.getOrCreateCounter)(name, { description, ...options });
+        }
+        counterMetric.add(1);
+        return originalFunction.apply(this, args);
+    };
+    descriptor.value = new Proxy(originalFunction, {
+        apply: (_, thisArg, args) => wrappedFunction.apply(thisArg, args),
+    });
+    (0, opentelemetry_utils_1.copyMetadataFromFunctionToFunction)(originalFunction, descriptor.value);
+};
+exports.OtelMethodCounter = OtelMethodCounter;

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

@@ -0,0 +1 @@
+import "reflect-metadata";

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

@@ -0,0 +1,53 @@
+"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 });
+require("reflect-metadata");
+const common_1 = require("@nestjs/common");
+const common_2 = require("./common");
+const TestDecoratorThatSetsMetadata = () => (0, common_1.SetMetadata)("some-metadata", true);
+let TestClass = class TestClass {
+    method() { }
+};
+__decorate([
+    TestDecoratorThatSetsMetadata(),
+    (0, common_2.OtelMethodCounter)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestClass.prototype, "method", null);
+TestClass = __decorate([
+    (0, common_2.OtelInstanceCounter)(),
+    TestDecoratorThatSetsMetadata()
+], TestClass);
+describe("OtelInstanceCounter", () => {
+    let instance;
+    beforeEach(() => {
+        instance = new TestClass();
+    });
+    it("should maintain reflect metadata", async () => {
+        expect(Reflect.getMetadata("some-metadata", instance.constructor)).toEqual(true);
+    });
+    it("should preserve the original class name", async () => {
+        expect(instance.constructor.name).toEqual("TestClass");
+    });
+});
+describe("OtelMethodCounter", () => {
+    let instance;
+    beforeEach(() => {
+        instance = new TestClass();
+    });
+    it("should maintain reflect metadata", async () => {
+        expect(Reflect.getMetadata("some-metadata", instance.method)).toEqual(true);
+    });
+    it("should preserve the original method name", async () => {
+        expect(instance.method.name).toEqual("method");
+    });
+});

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

@@ -0,0 +1,2 @@
+export * from "./common";
+export * from "./param";

package/lib/metrics/decorators/index.js

@@ -0,0 +1,18 @@
+"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("./param"), exports);

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

@@ -0,0 +1,9 @@
+import type { OtelMetricOptions } from "../../interfaces/metric-options.interface";
+export type MetricParamDecorator = (name: string, options?: OtelMetricOptions) => ParameterDecorator;
+export declare const OtelCounter: MetricParamDecorator;
+export declare const OtelUpDownCounter: MetricParamDecorator;
+export declare const OtelGauge: MetricParamDecorator;
+export declare const OtelHistogram: MetricParamDecorator;
+export declare const OtelObservableGauge: MetricParamDecorator;
+export declare const OtelObservableCounter: MetricParamDecorator;
+export declare const OtelObservableUpDownCounter: MetricParamDecorator;

package/lib/metrics/decorators/param.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelObservableUpDownCounter = exports.OtelObservableCounter = exports.OtelObservableGauge = exports.OtelHistogram = exports.OtelGauge = exports.OtelUpDownCounter = exports.OtelCounter = void 0;
+const common_1 = require("@nestjs/common");
+const metric_data_1 = require("../metric-data");
+function createMetricParamDecorator(type, getOrCreateMetric) {
+    return (name, options) => (0, common_1.createParamDecorator)(() => {
+        if (!name || name.length === 0) {
+            throw new Error(`${type} need a name argument`);
+        }
+        return getOrCreateMetric(name, options);
+    })();
+}
+exports.OtelCounter = createMetricParamDecorator("OtelCounter", metric_data_1.getOrCreateCounter);
+exports.OtelUpDownCounter = createMetricParamDecorator("OtelUpDownCounter", metric_data_1.getOrCreateUpDownCounter);
+exports.OtelGauge = createMetricParamDecorator("OtelGauge", metric_data_1.getOrCreateGauge);
+exports.OtelHistogram = createMetricParamDecorator("OtelHistogram", metric_data_1.getOrCreateHistogram);
+exports.OtelObservableGauge = createMetricParamDecorator("OtelObservableGauge", metric_data_1.getOrCreateObservableGauge);
+exports.OtelObservableCounter = createMetricParamDecorator("OtelObservableCounter", metric_data_1.getOrCreateObservableCounter);
+exports.OtelObservableUpDownCounter = createMetricParamDecorator("OtelObservableUpDownCounter", metric_data_1.getOrCreateObservableUpDownCounter);

package/lib/metrics/injector.d.ts

@@ -0,0 +1 @@
+export declare function InjectMetric(name: string): (target: Record<string, unknown>, key: string | symbol, index?: number | undefined) => void;

package/lib/metrics/injector.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectMetric = InjectMetric;
+const common_1 = require("@nestjs/common");
+const utils_1 = require("./utils");
+function InjectMetric(name) {
+    const token = (0, utils_1.getToken)(name);
+    return (0, common_1.Inject)(token);
+}

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

@@ -0,0 +1,20 @@
+import { type Counter, type Gauge, type Histogram, type ObservableCounter, type ObservableGauge, type ObservableUpDownCounter, type UpDownCounter } from "@opentelemetry/api";
+import type { OtelMetricOptions } from "../interfaces/metric-options.interface";
+export type GenericMetric = Counter | UpDownCounter | Histogram | Gauge | ObservableGauge | ObservableCounter | ObservableUpDownCounter;
+export declare enum MetricType {
+    Counter = "Counter",
+    UpDownCounter = "UpDownCounter",
+    Histogram = "Histogram",
+    Gauge = "Gauge",
+    ObservableGauge = "ObservableGauge",
+    ObservableCounter = "ObservableCounter",
+    ObservableUpDownCounter = "ObservableUpDownCounter"
+}
+export declare const meterData: Map<string, GenericMetric>;
+export declare function getOrCreateHistogram(name: string, options?: OtelMetricOptions): Histogram;
+export declare function getOrCreateCounter(name: string, options?: OtelMetricOptions): Counter;
+export declare function getOrCreateGauge(name: string, options?: OtelMetricOptions): Gauge;
+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

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meterData = exports.MetricType = void 0;
+exports.getOrCreateHistogram = getOrCreateHistogram;
+exports.getOrCreateCounter = getOrCreateCounter;
+exports.getOrCreateGauge = getOrCreateGauge;
+exports.getOrCreateUpDownCounter = getOrCreateUpDownCounter;
+exports.getOrCreateObservableGauge = getOrCreateObservableGauge;
+exports.getOrCreateObservableCounter = getOrCreateObservableCounter;
+exports.getOrCreateObservableUpDownCounter = getOrCreateObservableUpDownCounter;
+const api_1 = require("@opentelemetry/api");
+const opentelemetry_constants_1 = require("../opentelemetry.constants");
+var MetricType;
+(function (MetricType) {
+    MetricType["Counter"] = "Counter";
+    MetricType["UpDownCounter"] = "UpDownCounter";
+    MetricType["Histogram"] = "Histogram";
+    MetricType["Gauge"] = "Gauge";
+    MetricType["ObservableGauge"] = "ObservableGauge";
+    MetricType["ObservableCounter"] = "ObservableCounter";
+    MetricType["ObservableUpDownCounter"] = "ObservableUpDownCounter";
+})(MetricType || (exports.MetricType = MetricType = {}));
+exports.meterData = new Map();
+function getOrCreate(name, 
+// biome-ignore lint/style/useDefaultParameterLast: backward compatibility
+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);
+        switch (type) {
+            case MetricType.Counter:
+                metric = meter.createCounter(nameWithPrefix, options);
+                break;
+            case MetricType.UpDownCounter:
+                metric = meter.createUpDownCounter(nameWithPrefix, options);
+                break;
+            case MetricType.Histogram:
+                metric = meter.createHistogram(nameWithPrefix, options);
+                break;
+            case MetricType.Gauge:
+                metric = meter.createGauge(nameWithPrefix, options);
+                break;
+            case MetricType.ObservableGauge:
+                metric = meter.createObservableGauge(nameWithPrefix, options);
+                break;
+            case MetricType.ObservableCounter:
+                metric = meter.createObservableCounter(nameWithPrefix, options);
+                break;
+            case MetricType.ObservableUpDownCounter:
+                metric = meter.createObservableUpDownCounter(nameWithPrefix, options);
+                break;
+            default:
+                break;
+        }
+        if (metric) {
+            exports.meterData.set(nameWithPrefix, metric);
+        }
+    }
+    return metric;
+}
+function getOrCreateHistogram(name, options = {}) {
+    return getOrCreate(name, options, MetricType.Histogram);
+}
+function getOrCreateCounter(name, options = {}) {
+    return getOrCreate(name, options, MetricType.Counter);
+}
+function getOrCreateGauge(name, options = {}) {
+    return getOrCreate(name, options, MetricType.Gauge);
+}
+function getOrCreateUpDownCounter(name, options = {}) {
+    return getOrCreate(name, options, MetricType.UpDownCounter);
+}
+function getOrCreateObservableGauge(name, options = {}) {
+    return getOrCreate(name, options, MetricType.ObservableGauge);
+}
+function getOrCreateObservableCounter(name, options = {}) {
+    return getOrCreate(name, options, MetricType.ObservableCounter);
+}
+function getOrCreateObservableUpDownCounter(name, options = {}) {
+    return getOrCreate(name, options, MetricType.ObservableUpDownCounter);
+}

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

@@ -0,0 +1,10 @@
+import type { OtelMetricOptions } from "../interfaces/metric-options.interface";
+export declare class MetricService {
+    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>;
+    getGauge(name: string, options?: OtelMetricOptions): import("@opentelemetry/api").Gauge<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

@@ -0,0 +1,38 @@
+"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 common_1 = require("@nestjs/common");
+const metric_data_1 = require("./metric-data");
+let MetricService = class MetricService {
+    getCounter(name, options) {
+        return (0, metric_data_1.getOrCreateCounter)(name, options);
+    }
+    getUpDownCounter(name, options) {
+        return (0, metric_data_1.getOrCreateUpDownCounter)(name, options);
+    }
+    getHistogram(name, options) {
+        return (0, metric_data_1.getOrCreateHistogram)(name, options);
+    }
+    getGauge(name, options) {
+        return (0, metric_data_1.getOrCreateGauge)(name, options);
+    }
+    getObservableCounter(name, options) {
+        return (0, metric_data_1.getOrCreateObservableCounter)(name, options);
+    }
+    getObservableGauge(name, options) {
+        return (0, metric_data_1.getOrCreateObservableGauge)(name, options);
+    }
+    getObservableUpDownCounter(name, options) {
+        return (0, metric_data_1.getOrCreateObservableUpDownCounter)(name, options);
+    }
+};
+exports.MetricService = MetricService;
+exports.MetricService = MetricService = __decorate([
+    (0, common_1.Injectable)()
+], MetricService);

package/lib/metrics/utils.d.ts

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

package/lib/metrics/utils.js

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

package/lib/metrics/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/metrics/utils.spec.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+describe("metrics - Utils", () => {
+    describe("getToken", () => {
+        it("returns uppercase token", () => {
+            expect((0, utils_1.getToken)("foo")).toBe("OTEL_METRIC_FOO");
+        });
+    });
+});

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

@@ -0,0 +1,38 @@
+/** biome-ignore-all lint/style/useImportType: backward compatibility */
+import { DynamicModule, 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;
+    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;
+    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;
+}