@vendure/telemetry-plugin 3.3.0

package/LICENSE.md

@@ -0,0 +1,42 @@
+# License
+Copyright (C) Vendure GmbH
+
+This software is available under two different licenses:
+* GNU General Public License version 3 (GPLv3) as Vendure Community Edition
+* Vendure Commercial License (VCL)
+
+The default Vendure license, without a valid Vendure Commercial License agreement, is the Open-Source GPLv3 license.
+
+## GNU General Public License version 3 (GPLv3)
+
+If you decide to choose the GPLv3 license, you must comply with the following terms:
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Additional permission under GNU GPL version 3 section 7:
+
+An additional exception under section 7 of the GPL is included in the plugin-exception.txt file,
+which allows you to distribute Vendure plugins (i.e. extensions) under a different license.
+
+## Vendure Commercial License (VCL)
+
+Alternatively, commercial and supported versions of the program - also known as
+Commercial Distributions - must be used in accordance with the terms and conditions
+contained in a separate written agreement between you and Vendure GmbH.
+For more information about the Vendure Commercial License (VCL) please contact contact@vendure.io.
+
+Please see also:
+
+- [Licensing FAQ - license-faq.md](license/license-faq.md)
+- [GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 - gpl-3.0.txt](license/gpl-3.0.txt)

package/dist/config/default-method-hooks.d.ts

@@ -0,0 +1,2 @@
+import { CacheService, EventBus, JobQueue, JobQueueService } from '@vendure/core';
+export declare const defaultMethodHooks: (import("..").MethodHookConfig<CacheService> | import("..").MethodHookConfig<EventBus> | import("..").MethodHookConfig<JobQueueService> | import("..").MethodHookConfig<JobQueue<import("@vendure/core").JsonCompatible<any>>>)[];

package/dist/config/default-method-hooks.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMethodHooks = void 0;
+const core_1 = require("@vendure/core");
+const javascript_stringify_1 = require("javascript-stringify");
+const method_hooks_service_1 = require("../service/method-hooks.service");
+exports.defaultMethodHooks = [
+    (0, method_hooks_service_1.registerMethodHooks)(core_1.CacheService, {
+        get: {
+            pre: ({ args: [key], span }) => {
+                span.setAttribute('cache.key', key);
+            },
+            post: ({ args: [key], result: hit, span }) => {
+                span.setAttribute('cache.hit', !!hit);
+                if (hit) {
+                    span.addEvent('cache.hit', { key });
+                }
+                else {
+                    span.addEvent('cache.miss', { key });
+                }
+            },
+        },
+        set: {
+            pre: ({ args: [key], span }) => {
+                span.setAttribute('cache.key', key);
+            },
+        },
+        delete: {
+            pre: ({ args: [key], span }) => {
+                span.setAttribute('cache.key', key);
+            },
+        },
+        invalidateTags: {
+            pre: ({ args: [tags], span }) => {
+                span.setAttribute('cache.tags', tags.join(', '));
+            },
+        },
+    }),
+    (0, method_hooks_service_1.registerMethodHooks)(core_1.EventBus, {
+        publish: {
+            pre: ({ args: [event], span }) => {
+                span.setAttribute('event', event.constructor.name);
+                span.setAttribute('event.timestamp', event.createdAt.toISOString());
+            },
+        },
+    }),
+    (0, method_hooks_service_1.registerMethodHooks)(core_1.JobQueueService, {
+        createQueue: {
+            pre: ({ args: [options], span }) => {
+                span.setAttribute('job-queue.name', options.name);
+            },
+        },
+    }),
+    (0, method_hooks_service_1.registerMethodHooks)(core_1.JobQueue, {
+        start: {
+            pre: ({ instance, span }) => {
+                span.setAttribute('job-queue.name', instance.name);
+            },
+        },
+        add: {
+            pre: ({ args: [data, options], span, instance }) => {
+                var _a, _b;
+                span.setAttribute('job.queueName', instance.name);
+                span.setAttribute('job.data', (_a = (0, javascript_stringify_1.stringify)(data, null, 2, {
+                    maxDepth: 3,
+                })) !== null && _a !== void 0 ? _a : '');
+                span.setAttribute('job.retries', (_b = options === null || options === void 0 ? void 0 : options.retries) !== null && _b !== void 0 ? _b : 0);
+            },
+            post({ result, span }) {
+                span.setAttribute('job.buffered', result.id === 'buffered');
+            },
+        },
+    }),
+];
+//# sourceMappingURL=default-method-hooks.js.map

package/dist/config/default-method-hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-method-hooks.js","sourceRoot":"","sources":["../../src/config/default-method-hooks.ts"],"names":[],"mappings":";;;AAAA,wCAAkF;AAClF,+DAAiD;AAEjD,0EAAsE;AAEzD,QAAA,kBAAkB,GAAG;IAC9B,IAAA,0CAAmB,EAAC,mBAAY,EAAE;QAC9B,GAAG,EAAE;YACD,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC3B,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;YACxC,CAAC;YACD,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,EAAE,EAAE;gBACzC,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;gBACtC,IAAI,GAAG,EAAE,CAAC;oBACN,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;gBACxC,CAAC;qBAAM,CAAC;oBACJ,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;gBACzC,CAAC;YACL,CAAC;SACJ;QACD,GAAG,EAAE;YACD,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC3B,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;YACxC,CAAC;SACJ;QACD,MAAM,EAAE;YACJ,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC3B,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC;YACxC,CAAC;SACJ;QACD,cAAc,EAAE;YACZ,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC5B,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;YACrD,CAAC;SACJ;KACJ,CAAC;IACF,IAAA,0CAAmB,EAAC,eAAQ,EAAE;QAC1B,OAAO,EAAE;YACL,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC7B,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;gBACnD,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;YACxE,CAAC;SACJ;KACJ,CAAC;IACF,IAAA,0CAAmB,EAAC,sBAAe,EAAE;QACjC,WAAW,EAAE;YACT,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;gBAC/B,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;YACtD,CAAC;SACJ;KACJ,CAAC;IACF,IAAA,0CAAmB,EAAC,eAAQ,EAAE;QAC1B,KAAK,EAAE;YACH,GAAG,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE;gBACxB,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;YACvD,CAAC;SACJ;QACD,GAAG,EAAE;YACD,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE;;gBAC/C,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAClD,IAAI,CAAC,YAAY,CACb,UAAU,EACV,MAAA,IAAA,gCAAS,EAAC,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE;oBACrB,QAAQ,EAAE,CAAC;iBACd,CAAC,mCAAI,EAAE,CACX,CAAC;gBACF,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,OAAO,mCAAI,CAAC,CAAC,CAAC;YAC5D,CAAC;YACD,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE;gBACjB,IAAI,CAAC,YAAY,CAAC,cAAc,EAAE,MAAM,CAAC,EAAE,KAAK,UAAU,CAAC,CAAC;YAChE,CAAC;SACJ;KACJ,CAAC;CACL,CAAC"}

package/dist/config/otel-instrumentation-strategy.d.ts

@@ -0,0 +1,7 @@
+import { Injector, InstrumentationStrategy, WrappedMethodArgs } from '@vendure/core';
+export declare const tracer: import("@opentelemetry/api").Tracer;
+export declare class OtelInstrumentationStrategy implements InstrumentationStrategy {
+    private spanAttributeService;
+    init(injector: Injector): void;
+    wrapMethod({ instance, target, methodName, args, applyOriginalFunction }: WrappedMethodArgs): any;
+}

package/dist/config/otel-instrumentation-strategy.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelInstrumentationStrategy = exports.tracer = void 0;
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@vendure/core");
+const method_hooks_service_1 = require("../service/method-hooks.service");
+exports.tracer = api_1.trace.getTracer('@vendure/core', core_1.VENDURE_VERSION);
+const recordException = (span, error) => {
+    span.recordException(error);
+    span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+};
+class OtelInstrumentationStrategy {
+    init(injector) {
+        this.spanAttributeService = injector.get(method_hooks_service_1.MethodHooksService);
+    }
+    wrapMethod({ instance, target, methodName, args, applyOriginalFunction }) {
+        const spanName = `${String(target.name)}.${String(methodName)}`;
+        return exports.tracer.startActiveSpan(spanName, {}, span => {
+            var _a, _b;
+            const hooks = (_a = this.spanAttributeService) === null || _a === void 0 ? void 0 : _a.getHooks(target, methodName);
+            (_b = hooks === null || hooks === void 0 ? void 0 : hooks.pre) === null || _b === void 0 ? void 0 : _b.call(hooks, { args, span, instance });
+            if (applyOriginalFunction.constructor.name === 'AsyncFunction') {
+                return (applyOriginalFunction()
+                    .then((result) => {
+                    if (hooks === null || hooks === void 0 ? void 0 : hooks.post) {
+                        hooks.post({ args, result, span, instance });
+                    }
+                    return result;
+                })
+                    // @ts-expect-error
+                    .catch(error => {
+                    recordException(span, error);
+                    // Throw error to propagate it further
+                    throw error;
+                })
+                    .finally(() => {
+                    span.end();
+                }));
+            }
+            try {
+                const result = applyOriginalFunction();
+                if (hooks === null || hooks === void 0 ? void 0 : hooks.post) {
+                    hooks.post({ args, result, span, instance });
+                }
+                return result;
+            }
+            catch (error) {
+                recordException(span, error);
+                // throw for further propagation
+                throw error;
+            }
+            finally {
+                span.end();
+            }
+        });
+    }
+}
+exports.OtelInstrumentationStrategy = OtelInstrumentationStrategy;
+//# sourceMappingURL=otel-instrumentation-strategy.js.map

package/dist/config/otel-instrumentation-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-instrumentation-strategy.js","sourceRoot":"","sources":["../../src/config/otel-instrumentation-strategy.ts"],"names":[],"mappings":";;;AAAA,4CAA4E;AAC5E,wCAAsG;AAEtG,0EAAqE;AAExD,QAAA,MAAM,GAAG,WAAK,CAAC,SAAS,CAAC,eAAe,EAAE,sBAAe,CAAC,CAAC;AAExE,MAAM,eAAe,GAAG,CAAC,IAAa,EAAE,KAAU,EAAE,EAAE;IAClD,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAC5B,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,oBAAc,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;AAC3E,CAAC,CAAC;AAEF,MAAa,2BAA2B;IAGpC,IAAI,CAAC,QAAkB;QACnB,IAAI,CAAC,oBAAoB,GAAG,QAAQ,CAAC,GAAG,CAAC,yCAAkB,CAAC,CAAC;IACjE,CAAC;IAED,UAAU,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,qBAAqB,EAAqB;QACvF,MAAM,QAAQ,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,UAAU,CAAC,EAAE,CAAC;QAEhE,OAAO,cAAM,CAAC,eAAe,CAAC,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE;;YAC/C,MAAM,KAAK,GAAG,MAAA,IAAI,CAAC,oBAAoB,0CAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;YACtE,MAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,GAAG,sDAAG,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;YACvC,IAAI,qBAAqB,CAAC,WAAW,CAAC,IAAI,KAAK,eAAe,EAAE,CAAC;gBAC7D,OAAO,CACH,qBAAqB,EAAE;qBAClB,IAAI,CAAC,CAAC,MAAW,EAAE,EAAE;oBAClB,IAAI,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,IAAI,EAAE,CAAC;wBACd,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;oBACjD,CAAC;oBACD,OAAO,MAAM,CAAC;gBAClB,CAAC,CAAC;oBACF,mBAAmB;qBAClB,KAAK,CAAC,KAAK,CAAC,EAAE;oBACX,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;oBAC7B,sCAAsC;oBACtC,MAAM,KAAK,CAAC;gBAChB,CAAC,CAAC;qBACD,OAAO,CAAC,GAAG,EAAE;oBACV,IAAI,CAAC,GAAG,EAAE,CAAC;gBACf,CAAC,CAAC,CACT,CAAC;YACN,CAAC;YAED,IAAI,CAAC;gBACD,MAAM,MAAM,GAAG,qBAAqB,EAAE,CAAC;gBACvC,IAAI,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,IAAI,EAAE,CAAC;oBACd,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;gBACjD,CAAC;gBACD,OAAO,MAAM,CAAC;YAClB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBAE7B,gCAAgC;gBAChC,MAAM,KAAK,CAAC;YAChB,CAAC;oBAAS,CAAC;gBACP,IAAI,CAAC,GAAG,EAAE,CAAC;YACf,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AAlDD,kEAkDC"}

package/dist/config/otel-logger.d.ts

@@ -0,0 +1,51 @@
+import { LogLevel, VendureLogger } from '@vendure/core';
+export declare const otelLogger: import("@opentelemetry/api-logs").Logger;
+/**
+ * @description
+ * Options for the OtelLogger.
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ * @docsPage OtelLogger
+ */
+export interface OtelLoggerOptions {
+    /**
+     * @description
+     * If set to a LogLevel, the logger will also log to the console.
+     * This can be useful for local development or debugging.
+     *
+     * @example
+     * ```ts
+     * import { LogLevel } from '@vendure/core';
+     * import { TelemetryPlugin } from '@vendure/telemetry-plugin';
+     *
+     * // ...
+     *
+     * TelemetryPlugin.init({
+     *   loggerOptions: {
+     *     logToConsole: LogLevel.Verbose,
+     *   },
+     * });
+     * ```
+     */
+    logToConsole?: LogLevel;
+}
+/**
+ * @description
+ * A logger that emits logs to OpenTelemetry and optionally to the console.
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ * @docsPage OtelLogger
+ * @docsWeight 0
+ */
+export declare class OtelLogger implements VendureLogger {
+    private defaultLogger?;
+    constructor(options: OtelLoggerOptions);
+    debug(message: string, context?: string): void;
+    warn(message: string, context?: string): void;
+    info(message: string, context?: string): void;
+    error(message: string, context?: string): void;
+    verbose(message: string, context?: string): void;
+    private emitLog;
+}

package/dist/config/otel-logger.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OtelLogger = exports.otelLogger = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+const core_1 = require("@vendure/core");
+exports.otelLogger = api_logs_1.logs.getLogger('@vendure/core', core_1.VENDURE_VERSION);
+/**
+ * @description
+ * A logger that emits logs to OpenTelemetry and optionally to the console.
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ * @docsPage OtelLogger
+ * @docsWeight 0
+ */
+class OtelLogger {
+    constructor(options) {
+        if (options.logToConsole) {
+            this.defaultLogger = new core_1.DefaultLogger({
+                level: options.logToConsole,
+                timestamp: false,
+            });
+        }
+    }
+    debug(message, context) {
+        var _a;
+        this.emitLog(api_logs_1.SeverityNumber.DEBUG, message, context);
+        (_a = this.defaultLogger) === null || _a === void 0 ? void 0 : _a.debug(message, context);
+    }
+    warn(message, context) {
+        var _a;
+        this.emitLog(api_logs_1.SeverityNumber.WARN, message, context);
+        (_a = this.defaultLogger) === null || _a === void 0 ? void 0 : _a.warn(message, context);
+    }
+    info(message, context) {
+        var _a;
+        this.emitLog(api_logs_1.SeverityNumber.INFO, message, context);
+        (_a = this.defaultLogger) === null || _a === void 0 ? void 0 : _a.info(message, context);
+    }
+    error(message, context) {
+        var _a;
+        this.emitLog(api_logs_1.SeverityNumber.ERROR, message, context);
+        (_a = this.defaultLogger) === null || _a === void 0 ? void 0 : _a.error(message, context);
+    }
+    verbose(message, context) {
+        var _a;
+        this.emitLog(api_logs_1.SeverityNumber.DEBUG, message, context);
+        (_a = this.defaultLogger) === null || _a === void 0 ? void 0 : _a.verbose(message, context);
+    }
+    emitLog(severityNumber, message, context, label) {
+        exports.otelLogger.emit({
+            severityNumber,
+            body: message,
+            attributes: Object.assign({ context, service_name: 'vendure' }, (label ? { label } : {})),
+        });
+    }
+}
+exports.OtelLogger = OtelLogger;
+//# sourceMappingURL=otel-logger.js.map

package/dist/config/otel-logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"otel-logger.js","sourceRoot":"","sources":["../../src/config/otel-logger.ts"],"names":[],"mappings":";;;AAAA,sDAA+D;AAC/D,wCAAwF;AAE3E,QAAA,UAAU,GAAG,eAAI,CAAC,SAAS,CAAC,eAAe,EAAE,sBAAe,CAAC,CAAC;AAiC3E;;;;;;;;GAQG;AACH,MAAa,UAAU;IAGnB,YAAY,OAA0B;QAClC,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;YACvB,IAAI,CAAC,aAAa,GAAG,IAAI,oBAAa,CAAC;gBACnC,KAAK,EAAE,OAAO,CAAC,YAAY;gBAC3B,SAAS,EAAE,KAAK;aACnB,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,OAAgB;;QACnC,IAAI,CAAC,OAAO,CAAC,yBAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACrD,MAAA,IAAI,CAAC,aAAa,0CAAE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,OAAgB;;QAClC,IAAI,CAAC,OAAO,CAAC,yBAAc,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACpD,MAAA,IAAI,CAAC,aAAa,0CAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,OAAgB;;QAClC,IAAI,CAAC,OAAO,CAAC,yBAAc,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACpD,MAAA,IAAI,CAAC,aAAa,0CAAE,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,OAAgB;;QACnC,IAAI,CAAC,OAAO,CAAC,yBAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACrD,MAAA,IAAI,CAAC,aAAa,0CAAE,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAChD,CAAC;IAED,OAAO,CAAC,OAAe,EAAE,OAAgB;;QACrC,IAAI,CAAC,OAAO,CAAC,yBAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;QACrD,MAAA,IAAI,CAAC,aAAa,0CAAE,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IAEO,OAAO,CAAC,cAA8B,EAAE,OAAe,EAAE,OAAgB,EAAE,KAAc;QAC7F,kBAAU,CAAC,IAAI,CAAC;YACZ,cAAc;YACd,IAAI,EAAE,OAAO;YACb,UAAU,kBACN,OAAO,EACP,YAAY,EAAE,SAAS,IACpB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAC9B;SACJ,CAAC,CAAC;IACP,CAAC;CACJ;AAhDD,gCAgDC"}

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const TELEMETRY_PLUGIN_OPTIONS: unique symbol;

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TELEMETRY_PLUGIN_OPTIONS = void 0;
+exports.TELEMETRY_PLUGIN_OPTIONS = Symbol('TELEMETRY_PLUGIN_OPTIONS');
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,wBAAwB,GAAG,MAAM,CAAC,0BAA0B,CAAC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config/default-method-hooks';
+export * from './config/otel-instrumentation-strategy';
+export * from './config/otel-logger';
+export * from './service/method-hooks.service';
+export * from './telemetry.plugin';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,23 @@
+"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("./config/default-method-hooks"), exports);
+__exportStar(require("./config/otel-instrumentation-strategy"), exports);
+__exportStar(require("./config/otel-logger"), exports);
+__exportStar(require("./service/method-hooks.service"), exports);
+__exportStar(require("./telemetry.plugin"), exports);
+__exportStar(require("./types"), exports);
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,gEAA8C;AAC9C,yEAAuD;AACvD,uDAAqC;AACrC,iEAA+C;AAC/C,qDAAmC;AACnC,0CAAwB"}

package/dist/instrumentation.d.ts

@@ -0,0 +1,70 @@
+import { NodeSDKConfiguration } from '@opentelemetry/sdk-node';
+/**
+ * @description
+ * Options for configuring the OpenTelemetry Node SDK.
+ *
+ * @docsCategory core plugins/TelemetryPlugin
+ * @docsPage getSdkConfiguration
+ */
+export interface SdkConfigurationOptions {
+    /**
+     * @description
+     * When set to `true`, the SDK will log spans to the console instead of sending them to an
+     * exporter. This should just be used for debugging purposes.
+     *
+     * @default false
+     */
+    logToConsole?: boolean;
+    /**
+     * @description
+     * The configuration object for the OpenTelemetry Node SDK.
+     */
+    config: Partial<NodeSDKConfiguration>;
+}
+/**
+ * @description
+ * Creates a configuration object for the OpenTelemetry Node SDK. This is used to set up a custom
+ * preload script which must be run before the main Vendure server is loaded by means of the
+ * Node.js `--require` flag.
+ *
+ * @example
+ * ```ts
+ * // instrumentation.ts
+ * import { OTLPLogExporter } from '\@opentelemetry/exporter-logs-otlp-proto';
+ * import { OTLPTraceExporter } from '\@opentelemetry/exporter-trace-otlp-http';
+ * import { BatchLogRecordProcessor } from '\@opentelemetry/sdk-logs';
+ * import { NodeSDK } from '\@opentelemetry/sdk-node';
+ * import { BatchSpanProcessor } from '\@opentelemetry/sdk-trace-base';
+ * import { getSdkConfiguration } from '\@vendure/telemetry-plugin/preload';
+ *
+ * process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:3100/otlp';
+ * process.env.OTEL_LOGS_EXPORTER = 'otlp';
+ * process.env.OTEL_RESOURCE_ATTRIBUTES = 'service.name=vendure-dev-server';
+ *
+ * const traceExporter = new OTLPTraceExporter({
+ *     url: 'http://localhost:4318/v1/traces',
+ * });
+ * const logExporter = new OTLPLogExporter();
+ *
+ * const config = getSdkConfiguration({
+ *     config: {
+ *         spanProcessors: [new BatchSpanProcessor(traceExporter)],
+ *         logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
+ *     },
+ * });
+ *
+ * const sdk = new NodeSDK(config);
+ *
+ * sdk.start();
+ * ```
+ *
+ * This would them be run as:
+ * ```bash
+ * node --require ./dist/instrumentation.js ./dist/server.js
+ * ```
+ *
+ * @docsCategory core plugins/TelemetryPlugin
+ * @docsPage getSdkConfiguration
+ * @docsWeight 0
+ */
+export declare function getSdkConfiguration(options?: SdkConfigurationOptions): Partial<NodeSDKConfiguration>;

package/dist/instrumentation.js

@@ -0,0 +1,94 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSdkConfiguration = getSdkConfiguration;
+const auto_instrumentations_node_1 = require("@opentelemetry/auto-instrumentations-node");
+const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
+const exporter_logs_otlp_proto_1 = require("@opentelemetry/exporter-logs-otlp-proto");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+// Deep import is intentional: otherwise unwanted code (such as instrumented classes) will get
+// loaded too early before the Otel instrumentation has had a chance to do its thing.
+const instrument_decorator_1 = require("@vendure/core/dist/common/instrument-decorator");
+const traceExporter = new exporter_trace_otlp_http_1.OTLPTraceExporter();
+const logExporter = new exporter_logs_otlp_proto_1.OTLPLogExporter();
+/**
+ * @description
+ * Creates a configuration object for the OpenTelemetry Node SDK. This is used to set up a custom
+ * preload script which must be run before the main Vendure server is loaded by means of the
+ * Node.js `--require` flag.
+ *
+ * @example
+ * ```ts
+ * // instrumentation.ts
+ * import { OTLPLogExporter } from '\@opentelemetry/exporter-logs-otlp-proto';
+ * import { OTLPTraceExporter } from '\@opentelemetry/exporter-trace-otlp-http';
+ * import { BatchLogRecordProcessor } from '\@opentelemetry/sdk-logs';
+ * import { NodeSDK } from '\@opentelemetry/sdk-node';
+ * import { BatchSpanProcessor } from '\@opentelemetry/sdk-trace-base';
+ * import { getSdkConfiguration } from '\@vendure/telemetry-plugin/preload';
+ *
+ * process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:3100/otlp';
+ * process.env.OTEL_LOGS_EXPORTER = 'otlp';
+ * process.env.OTEL_RESOURCE_ATTRIBUTES = 'service.name=vendure-dev-server';
+ *
+ * const traceExporter = new OTLPTraceExporter({
+ *     url: 'http://localhost:4318/v1/traces',
+ * });
+ * const logExporter = new OTLPLogExporter();
+ *
+ * const config = getSdkConfiguration({
+ *     config: {
+ *         spanProcessors: [new BatchSpanProcessor(traceExporter)],
+ *         logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
+ *     },
+ * });
+ *
+ * const sdk = new NodeSDK(config);
+ *
+ * sdk.start();
+ * ```
+ *
+ * This would them be run as:
+ * ```bash
+ * node --require ./dist/instrumentation.js ./dist/server.js
+ * ```
+ *
+ * @docsCategory core plugins/TelemetryPlugin
+ * @docsPage getSdkConfiguration
+ * @docsWeight 0
+ */
+function getSdkConfiguration(options) {
+    var _a;
+    // This environment variable is used to enable instrumentation in the Vendure core code.
+    // Without setting this env var, no instrumentation will be applied to any Vendure classes.
+    process.env[instrument_decorator_1.ENABLE_INSTRUMENTATION_ENV_VAR] = 'true';
+    const _b = (_a = options === null || options === void 0 ? void 0 : options.config) !== null && _a !== void 0 ? _a : {}, { spanProcessors, logRecordProcessors } = _b, rest = __rest(_b, ["spanProcessors", "logRecordProcessors"]);
+    const devModeAwareConfig = (options === null || options === void 0 ? void 0 : options.logToConsole)
+        ? {
+            spanProcessors: [new sdk_trace_base_1.SimpleSpanProcessor(new sdk_trace_base_1.ConsoleSpanExporter())],
+            logRecordProcessors: [new sdk_logs_1.SimpleLogRecordProcessor(new sdk_logs_1.ConsoleLogRecordExporter())],
+        }
+        : {
+            spanProcessors: spanProcessors !== null && spanProcessors !== void 0 ? spanProcessors : [new sdk_trace_base_1.BatchSpanProcessor(traceExporter)],
+            logRecordProcessors: logRecordProcessors !== null && logRecordProcessors !== void 0 ? logRecordProcessors : [new sdk_logs_1.BatchLogRecordProcessor(logExporter)],
+        };
+    return Object.assign(Object.assign(Object.assign({ resource: (0, resources_1.resourceFromAttributes)({
+            'service.name': 'vendure',
+            'service.namespace': 'vendure',
+            'service.environment': process.env.NODE_ENV || 'development',
+        }) }, devModeAwareConfig), { contextManager: new context_async_hooks_1.AsyncLocalStorageContextManager(), instrumentations: [(0, auto_instrumentations_node_1.getNodeAutoInstrumentations)()] }), rest);
+}
+//# sourceMappingURL=instrumentation.js.map

package/dist/instrumentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.js","sourceRoot":"","sources":["../src/instrumentation.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAwFA,kDA2BC;AAnHD,0FAAwF;AACxF,4EAAqF;AACrF,sFAA0E;AAC1E,sFAA4E;AAC5E,wDAAkE;AAClE,sDAIiC;AAEjC,kEAA6G;AAC7G,8FAA8F;AAC9F,qFAAqF;AACrF,yFAAgG;AAEhG,MAAM,aAAa,GAAG,IAAI,4CAAiB,EAAE,CAAC;AAC9C,MAAM,WAAW,GAAG,IAAI,0CAAe,EAAE,CAAC;AAyB1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,SAAgB,mBAAmB,CAAC,OAAiC;;IACjE,wFAAwF;IACxF,2FAA2F;IAC3F,OAAO,CAAC,GAAG,CAAC,qDAA8B,CAAC,GAAG,MAAM,CAAC;IACrD,MAAM,KAAmD,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,MAAM,mCAAI,EAAE,EAAxE,EAAE,cAAc,EAAE,mBAAmB,OAAmC,EAA9B,IAAI,cAA9C,yCAAgD,CAAwB,CAAC;IAE/E,MAAM,kBAAkB,GAAkC,CAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,YAAY;QAC3E,CAAC,CAAC;YACI,cAAc,EAAE,CAAC,IAAI,oCAAmB,CAAC,IAAI,oCAAmB,EAAE,CAAC,CAAC;YACpE,mBAAmB,EAAE,CAAC,IAAI,mCAAwB,CAAC,IAAI,mCAAwB,EAAE,CAAC,CAAC;SACtF;QACH,CAAC,CAAC;YACI,cAAc,EAAE,cAAc,aAAd,cAAc,cAAd,cAAc,GAAI,CAAC,IAAI,mCAAkB,CAAC,aAAa,CAAC,CAAC;YACzE,mBAAmB,EAAE,mBAAmB,aAAnB,mBAAmB,cAAnB,mBAAmB,GAAI,CAAC,IAAI,kCAAuB,CAAC,WAAW,CAAC,CAAC;SACzF,CAAC;IAER,mDACI,QAAQ,EAAE,IAAA,kCAAsB,EAAC;YAC7B,cAAc,EAAE,SAAS;YACzB,mBAAmB,EAAE,SAAS;YAC9B,qBAAqB,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,IAAI,aAAa;SAC/D,CAAC,IACC,kBAAkB,KACrB,cAAc,EAAE,IAAI,qDAA+B,EAAE,EACrD,gBAAgB,EAAE,CAAC,IAAA,wDAA2B,GAAE,CAAC,KAC9C,IAAI,EACT;AACN,CAAC"}

package/dist/service/method-hooks.service.d.ts

@@ -0,0 +1,60 @@
+import { Span } from '@opentelemetry/api';
+import { Type } from '@vendure/common/lib/shared-types';
+import { MethodHookConfig } from '../types';
+/**
+ * Extracts only the method names from a class type T
+ */
+export type MethodNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+export type Unwrap<T> = T extends Promise<infer U> ? U : T;
+type MethodType<T, K extends keyof T> = T[K] extends (...args: any[]) => any ? T[K] : never;
+export interface InstrumentedMethodHooks<T, Method extends MethodNames<T>> {
+    pre?: (input: {
+        instance: T;
+        args: Parameters<MethodType<T, Method>>;
+        span: Span;
+    }) => void;
+    post?: (input: {
+        instance: T;
+        args: Parameters<MethodType<T, Method>>;
+        result: Unwrap<ReturnType<MethodType<T, Method>>>;
+        span: Span;
+    }) => void;
+}
+export type MethodHooksForType<T> = {
+    [K in MethodNames<T>]?: InstrumentedMethodHooks<T, K>;
+};
+/**
+ * @description
+ * Allows you to register hooks for a specific method of an instrumented class.
+ * These hooks allow extra telemetry actions to be performed on the method.
+ *
+ * They can then be passed to the {@link TelemetryPlugin} via the {@link TelemetryPluginOptions}.
+ *
+ * @example
+ * ```typescript
+ * const productServiceHooks = registerMethodHooks(ProductService, {
+ *     findOne: {
+ *         // This will be called before the method is executed
+ *         pre: ({ args: [ctx, productId], span }) => {
+ *             span.setAttribute('productId', productId);
+ *         },
+ *         // This will be called after the method is executed
+ *         post: ({ result, span }) => {
+ *             span.setAttribute('found', !!result);
+ *         },
+ *     },
+ * });
+ * ```
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ */
+export declare function registerMethodHooks<T>(target: Type<T>, hooks: MethodHooksForType<T>): MethodHookConfig<T>;
+export declare class MethodHooksService {
+    private hooksMap;
+    registerHooks<T>(target: Type<T>, hooks: MethodHooksForType<T>): void;
+    getHooks<T>(target: T, methodName: string): InstrumentedMethodHooks<T, any> | undefined;
+}
+export {};

package/dist/service/method-hooks.service.js

@@ -0,0 +1,68 @@
+"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.MethodHooksService = void 0;
+exports.registerMethodHooks = registerMethodHooks;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+/**
+ * @description
+ * Allows you to register hooks for a specific method of an instrumented class.
+ * These hooks allow extra telemetry actions to be performed on the method.
+ *
+ * They can then be passed to the {@link TelemetryPlugin} via the {@link TelemetryPluginOptions}.
+ *
+ * @example
+ * ```typescript
+ * const productServiceHooks = registerMethodHooks(ProductService, {
+ *     findOne: {
+ *         // This will be called before the method is executed
+ *         pre: ({ args: [ctx, productId], span }) => {
+ *             span.setAttribute('productId', productId);
+ *         },
+ *         // This will be called after the method is executed
+ *         post: ({ result, span }) => {
+ *             span.setAttribute('found', !!result);
+ *         },
+ *     },
+ * });
+ * ```
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ */
+function registerMethodHooks(target, hooks) {
+    return {
+        target,
+        hooks,
+    };
+}
+let MethodHooksService = class MethodHooksService {
+    constructor() {
+        this.hooksMap = new Map();
+    }
+    registerHooks(target, hooks) {
+        const instrumentedClassTarget = (0, core_1.getInstrumentedClassTarget)(target);
+        if (!instrumentedClassTarget) {
+            core_1.Logger.error(`Cannot register hooks for non-instrumented class: ${target.name}`);
+            return;
+        }
+        const existingHooks = this.hooksMap.get(instrumentedClassTarget);
+        const combinedHooks = Object.assign(Object.assign({}, existingHooks), hooks);
+        this.hooksMap.set(instrumentedClassTarget, combinedHooks);
+    }
+    getHooks(target, methodName) {
+        var _a;
+        return (_a = this.hooksMap.get(target)) === null || _a === void 0 ? void 0 : _a[methodName];
+    }
+};
+exports.MethodHooksService = MethodHooksService;
+exports.MethodHooksService = MethodHooksService = __decorate([
+    (0, common_1.Injectable)()
+], MethodHooksService);
+//# sourceMappingURL=method-hooks.service.js.map

package/dist/service/method-hooks.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-hooks.service.js","sourceRoot":"","sources":["../../src/service/method-hooks.service.ts"],"names":[],"mappings":";;;;;;;;;AA2DA,kDAKC;AAhED,2CAA4C;AAG5C,wCAAmE;AA8BnE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,SAAgB,mBAAmB,CAAI,MAAe,EAAE,KAA4B;IAChF,OAAO;QACH,MAAM;QACN,KAAK;KACR,CAAC;AACN,CAAC;AAGM,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAAxB;QACK,aAAQ,GAAG,IAAI,GAAG,EAAoE,CAAC;IAmBnG,CAAC;IAjBG,aAAa,CAAI,MAAe,EAAE,KAA4B;QAC1D,MAAM,uBAAuB,GAAG,IAAA,iCAA0B,EAAC,MAAM,CAAC,CAAC;QACnE,IAAI,CAAC,uBAAuB,EAAE,CAAC;YAC3B,aAAM,CAAC,KAAK,CAAC,qDAAqD,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;YACjF,OAAO;QACX,CAAC;QACD,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;QACjE,MAAM,aAAa,mCACZ,aAAa,GACb,KAAK,CACX,CAAC;QACF,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,uBAAuB,EAAE,aAAa,CAAC,CAAC;IAC9D,CAAC;IAED,QAAQ,CAAI,MAAS,EAAE,UAAkB;;QACrC,OAAO,MAAA,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,0CAAG,UAAU,CAAC,CAAC;IACnD,CAAC;CACJ,CAAA;AApBY,gDAAkB;6BAAlB,kBAAkB;IAD9B,IAAA,mBAAU,GAAE;GACA,kBAAkB,CAoB9B"}

package/dist/telemetry.plugin.d.ts

@@ -0,0 +1,103 @@
+import { MethodHooksService } from './service/method-hooks.service';
+import { TelemetryPluginOptions } from './types';
+/**
+ * @description
+ * The TelemetryPlugin is used to instrument the Vendure application and collect telemetry data using
+ * [OpenTelemetry](https://opentelemetry.io/).
+ *
+ * ## Installation
+ *
+ * ```
+ * npm install \@vendure/telemetry-plugin
+ * ```
+ *
+ * :::info
+ * For a complete guide to setting up and working with Open Telemetry, see
+ * the [Implementing Open Telemetry guide](/guides/how-to/telemetry/).
+ * :::
+ *
+ * ## Configuration
+ *
+ * The plugin is configured via the `TelemetryPlugin.init()` method. This method accepts an options object
+ * which defines the OtelLogger options and method hooks.
+ *
+ * @example
+ * ```ts
+ * import { VendureConfig } from '\@vendure/core';
+ * import { TelemetryPlugin, registerMethodHooks } from '\@vendure/telemetry-plugin';
+ *
+ * export const config: VendureConfig = {
+ *   // ...
+ *   plugins: [
+ *     TelemetryPlugin.init({
+ *       loggerOptions: {
+ *         // Log to the console at the verbose level
+ *         console: LogLevel.Verbose,
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ *
+ * ## Preloading the SDK
+ *
+ * In order to use the OpenTelemetry SDK, you must preload it before the Vendure server is started.
+ * This is done by using the `--require` flag when starting the server with a custom preload script.
+ *
+ * Create a file named `instrumentation.ts` in the root of your project and add the following code:
+ *
+ * ```ts
+ * import { OTLPLogExporter } from '\@opentelemetry/exporter-logs-otlp-proto';
+ * import { OTLPTraceExporter } from '\@opentelemetry/exporter-trace-otlp-http';
+ * import { BatchLogRecordProcessor } from '\@opentelemetry/sdk-logs';
+ * import { NodeSDK } from '\@opentelemetry/sdk-node';
+ * import { BatchSpanProcessor } from '\@opentelemetry/sdk-trace-base';
+ * import { getSdkConfiguration } from '\@vendure/telemetry-plugin/preload';
+ *
+ * // In this example we are using Loki as the OTLP endpoint for logging
+ * process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:3100/otlp';
+ * process.env.OTEL_LOGS_EXPORTER = 'otlp';
+ * process.env.OTEL_RESOURCE_ATTRIBUTES = 'service.name=vendure-dev-server';
+ *
+ * // We are using Jaeger as the OTLP endpoint for tracing
+ * const traceExporter = new OTLPTraceExporter({
+ *     url: 'http://localhost:4318/v1/traces',
+ * });
+ * const logExporter = new OTLPLogExporter();
+ *
+ * // The getSdkConfiguration method returns a configuration object for the OpenTelemetry Node SDK.
+ * // It also performs other configuration tasks such as setting a special environment variable
+ * // to enable instrumentation in the Vendure core code.
+ * const config = getSdkConfiguration({
+ *     config: {
+ *         // Pass in any custom configuration options for the Node SDK here
+ *         spanProcessors: [new BatchSpanProcessor(traceExporter)],
+ *         logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
+ *     },
+ * });
+ *
+ * const sdk = new NodeSDK(config);
+ *
+ * sdk.start();
+ * ```
+ *
+ * The server would then be started with the following command:
+ *
+ * ```bash
+ * node --require ./dist/instrumentation.js ./dist/server.js
+ * ```
+ *
+ * or for development with ts-node:
+ *
+ * ```bash
+ * npx ts-node --require ./src/instrumentation.ts ./src/server.ts
+ * ```
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ */
+export declare class TelemetryPlugin {
+    static options: TelemetryPluginOptions;
+    constructor(methodHooksService: MethodHooksService, options: TelemetryPluginOptions);
+    static init(options: TelemetryPluginOptions): typeof TelemetryPlugin;
+}

package/dist/telemetry.plugin.js

@@ -0,0 +1,158 @@
+"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 TelemetryPlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryPlugin = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const default_method_hooks_1 = require("./config/default-method-hooks");
+const otel_instrumentation_strategy_1 = require("./config/otel-instrumentation-strategy");
+const otel_logger_1 = require("./config/otel-logger");
+const constants_1 = require("./constants");
+const method_hooks_service_1 = require("./service/method-hooks.service");
+/**
+ * @description
+ * The TelemetryPlugin is used to instrument the Vendure application and collect telemetry data using
+ * [OpenTelemetry](https://opentelemetry.io/).
+ *
+ * ## Installation
+ *
+ * ```
+ * npm install \@vendure/telemetry-plugin
+ * ```
+ *
+ * :::info
+ * For a complete guide to setting up and working with Open Telemetry, see
+ * the [Implementing Open Telemetry guide](/guides/how-to/telemetry/).
+ * :::
+ *
+ * ## Configuration
+ *
+ * The plugin is configured via the `TelemetryPlugin.init()` method. This method accepts an options object
+ * which defines the OtelLogger options and method hooks.
+ *
+ * @example
+ * ```ts
+ * import { VendureConfig } from '\@vendure/core';
+ * import { TelemetryPlugin, registerMethodHooks } from '\@vendure/telemetry-plugin';
+ *
+ * export const config: VendureConfig = {
+ *   // ...
+ *   plugins: [
+ *     TelemetryPlugin.init({
+ *       loggerOptions: {
+ *         // Log to the console at the verbose level
+ *         console: LogLevel.Verbose,
+ *       },
+ *     }),
+ *   ],
+ * };
+ * ```
+ *
+ * ## Preloading the SDK
+ *
+ * In order to use the OpenTelemetry SDK, you must preload it before the Vendure server is started.
+ * This is done by using the `--require` flag when starting the server with a custom preload script.
+ *
+ * Create a file named `instrumentation.ts` in the root of your project and add the following code:
+ *
+ * ```ts
+ * import { OTLPLogExporter } from '\@opentelemetry/exporter-logs-otlp-proto';
+ * import { OTLPTraceExporter } from '\@opentelemetry/exporter-trace-otlp-http';
+ * import { BatchLogRecordProcessor } from '\@opentelemetry/sdk-logs';
+ * import { NodeSDK } from '\@opentelemetry/sdk-node';
+ * import { BatchSpanProcessor } from '\@opentelemetry/sdk-trace-base';
+ * import { getSdkConfiguration } from '\@vendure/telemetry-plugin/preload';
+ *
+ * // In this example we are using Loki as the OTLP endpoint for logging
+ * process.env.OTEL_EXPORTER_OTLP_ENDPOINT = 'http://localhost:3100/otlp';
+ * process.env.OTEL_LOGS_EXPORTER = 'otlp';
+ * process.env.OTEL_RESOURCE_ATTRIBUTES = 'service.name=vendure-dev-server';
+ *
+ * // We are using Jaeger as the OTLP endpoint for tracing
+ * const traceExporter = new OTLPTraceExporter({
+ *     url: 'http://localhost:4318/v1/traces',
+ * });
+ * const logExporter = new OTLPLogExporter();
+ *
+ * // The getSdkConfiguration method returns a configuration object for the OpenTelemetry Node SDK.
+ * // It also performs other configuration tasks such as setting a special environment variable
+ * // to enable instrumentation in the Vendure core code.
+ * const config = getSdkConfiguration({
+ *     config: {
+ *         // Pass in any custom configuration options for the Node SDK here
+ *         spanProcessors: [new BatchSpanProcessor(traceExporter)],
+ *         logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
+ *     },
+ * });
+ *
+ * const sdk = new NodeSDK(config);
+ *
+ * sdk.start();
+ * ```
+ *
+ * The server would then be started with the following command:
+ *
+ * ```bash
+ * node --require ./dist/instrumentation.js ./dist/server.js
+ * ```
+ *
+ * or for development with ts-node:
+ *
+ * ```bash
+ * npx ts-node --require ./src/instrumentation.ts ./src/server.ts
+ * ```
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ */
+let TelemetryPlugin = TelemetryPlugin_1 = class TelemetryPlugin {
+    constructor(methodHooksService, options) {
+        var _a;
+        if (process.env[core_1.ENABLE_INSTRUMENTATION_ENV_VAR]) {
+            const allMethodHooks = [...default_method_hooks_1.defaultMethodHooks, ...((_a = options.methodHooks) !== null && _a !== void 0 ? _a : [])];
+            for (const methodHook of allMethodHooks) {
+                methodHooksService.registerHooks(methodHook.target, methodHook.hooks);
+            }
+        }
+    }
+    static init(options) {
+        TelemetryPlugin_1.options = options;
+        return TelemetryPlugin_1;
+    }
+};
+exports.TelemetryPlugin = TelemetryPlugin;
+TelemetryPlugin.options = {};
+exports.TelemetryPlugin = TelemetryPlugin = TelemetryPlugin_1 = __decorate([
+    (0, core_1.VendurePlugin)({
+        imports: [core_1.PluginCommonModule],
+        providers: [
+            method_hooks_service_1.MethodHooksService,
+            {
+                provide: constants_1.TELEMETRY_PLUGIN_OPTIONS,
+                useFactory: () => TelemetryPlugin.options,
+            },
+        ],
+        configuration: config => {
+            var _a;
+            config.systemOptions.instrumentationStrategy = new otel_instrumentation_strategy_1.OtelInstrumentationStrategy();
+            config.logger = new otel_logger_1.OtelLogger((_a = TelemetryPlugin.options.loggerOptions) !== null && _a !== void 0 ? _a : {});
+            return config;
+        },
+        compatibility: '>3.3.0',
+    }),
+    __param(1, (0, common_1.Inject)(constants_1.TELEMETRY_PLUGIN_OPTIONS)),
+    __metadata("design:paramtypes", [method_hooks_service_1.MethodHooksService, Object])
+], TelemetryPlugin);
+//# sourceMappingURL=telemetry.plugin.js.map

package/dist/telemetry.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.plugin.js","sourceRoot":"","sources":["../src/telemetry.plugin.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAwC;AACxC,wCAAkG;AAElG,wEAAmE;AACnE,0FAAqF;AACrF,sDAAkD;AAClD,2CAAuD;AACvD,yEAAoE;AAGpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AAiBI,IAAM,eAAe,uBAArB,MAAM,eAAe;IAGxB,YACI,kBAAsC,EACJ,OAA+B;;QAEjE,IAAI,OAAO,CAAC,GAAG,CAAC,qCAA8B,CAAC,EAAE,CAAC;YAC9C,MAAM,cAAc,GAAG,CAAC,GAAG,yCAAkB,EAAE,GAAG,CAAC,MAAA,OAAO,CAAC,WAAW,mCAAI,EAAE,CAAC,CAAC,CAAC;YAC/E,KAAK,MAAM,UAAU,IAAI,cAAc,EAAE,CAAC;gBACtC,kBAAkB,CAAC,aAAa,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,CAAC;YAC1E,CAAC;QACL,CAAC;IACL,CAAC;IAED,MAAM,CAAC,IAAI,CAAC,OAA+B;QACvC,iBAAe,CAAC,OAAO,GAAG,OAAO,CAAC;QAClC,OAAO,iBAAe,CAAC;IAC3B,CAAC;;AAlBQ,0CAAe;AACjB,uBAAO,GAA2B,EAAE,AAA7B,CAA8B;0BADnC,eAAe;IAhB3B,IAAA,oBAAa,EAAC;QACX,OAAO,EAAE,CAAC,yBAAkB,CAAC;QAC7B,SAAS,EAAE;YACP,yCAAkB;YAClB;gBACI,OAAO,EAAE,oCAAwB;gBACjC,UAAU,EAAE,GAAG,EAAE,CAAC,eAAe,CAAC,OAAO;aAC5C;SACJ;QACD,aAAa,EAAE,MAAM,CAAC,EAAE;;YACpB,MAAM,CAAC,aAAa,CAAC,uBAAuB,GAAG,IAAI,2DAA2B,EAAE,CAAC;YACjF,MAAM,CAAC,MAAM,GAAG,IAAI,wBAAU,CAAC,MAAA,eAAe,CAAC,OAAO,CAAC,aAAa,mCAAI,EAAE,CAAC,CAAC;YAC5E,OAAO,MAAM,CAAC;QAClB,CAAC;QACD,aAAa,EAAE,QAAQ;KAC1B,CAAC;IAMO,WAAA,IAAA,eAAM,EAAC,oCAAwB,CAAC,CAAA;qCADb,yCAAkB;GAJjC,eAAe,CAmB3B"}

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+import { Type } from '@vendure/common/lib/shared-types';
+import { OtelLoggerOptions } from './config/otel-logger';
+import { MethodHooksForType } from './service/method-hooks.service';
+export interface MethodHookConfig<T> {
+    target: Type<T>;
+    hooks: MethodHooksForType<T>;
+}
+/**
+ * @description
+ * Configuration options for the TelemetryPlugin.
+ *
+ * @since 3.3.0
+ * @docsCategory core plugins/TelemetryPlugin
+ */
+export interface TelemetryPluginOptions {
+    /**
+     * @description
+     * The options for the OtelLogger.
+     *
+     * For example, to also include logging to the console, you can use the following:
+     * ```ts
+     * import { LogLevel } from '\@vendure/core';
+     * import { TelemetryPlugin } from '\@vendure/telemetry-plugin';
+     *
+     * TelemetryPlugin.init({
+     *     loggerOptions: {
+     *         console: LogLevel.Verbose,
+     *     },
+     * });
+     * ```
+     */
+    loggerOptions?: OtelLoggerOptions;
+    /**
+     * @description
+     * **Status: Developer Preview**
+     *
+     * This API may change in a future release.
+     *
+     * Method hooks allow you to add extra telemetry actions to specific methods.
+     * To define hooks on a method, use the {@link registerMethodHooks} function.
+     *
+     * @example
+     * ```ts
+     * import { TelemetryPlugin, registerMethodHooks } from '\@vendure/telemetry-plugin';
+     *
+     * TelemetryPlugin.init({
+     *   methodHooks: [
+     *     registerMethodHooks(ProductService, {
+     *
+     *       // Define some hooks for the `findOne` method
+     *       findOne: {
+     *         // This will be called before the method is executed
+     *         pre: ({ args: [ctx, productId], span }) => {
+     *           span.setAttribute('productId', productId);
+     *         },
+     *         // This will be called after the method is executed
+     *         post: ({ result, span }) => {
+     *           span.setAttribute('found', !!result);
+     *         },
+     *       },
+     *     }),
+     *   ],
+     * });
+     * ```
+     *
+     * @experimental
+     */
+    methodHooks?: Array<MethodHookConfig<any>>;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@vendure/telemetry-plugin",
+    "version": "3.3.0",
+    "description": "Telemetry for Vendure",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/vendure-ecommerce/vendure/"
+    },
+    "homepage": "https://www.vendure.io",
+    "funding": "https://github.com/sponsors/michaelbromley",
+    "private": false,
+    "license": "GPL-3.0-or-later",
+    "type": "commonjs",
+    "scripts": {
+        "build": "rimraf dist && tsc -p ./tsconfig.build.json",
+        "watch": "tsc -p ./tsconfig.build.json --watch"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist/**/*"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./preload": {
+            "types": "./dist/instrumentation.d.ts",
+            "default": "./dist/instrumentation.js"
+        }
+    },
+    "dependencies": {
+        "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/auto-instrumentations-node": "^0.58.0",
+        "@opentelemetry/context-async-hooks": "^2.0.0",
+        "@opentelemetry/exporter-logs-otlp-proto": "^0.200.0",
+        "@opentelemetry/exporter-trace-otlp-http": "^0.200.0",
+        "@opentelemetry/resources": "^2.0.0",
+        "@opentelemetry/sdk-logs": "^0.200.0",
+        "@opentelemetry/sdk-node": "^0.200.0",
+        "javascript-stringify": "^2.1.0"
+    },
+    "devDependencies": {
+        "@vendure/common": "3.3.0",
+        "@vendure/core": "3.3.0",
+        "typescript": "5.8.2"
+    },
+    "gitHead": "a4c56359ec831b0c54dd01eab14fb75455c43ab7"
+}