nestjs-otel 8.0.2 → 8.0.3

package/lib/tracing/decorators/span.js

@@ -44,9 +44,7 @@ function Span(nameOrOptions, maybeOptions) {
             return tracer.startActiveSpan(name, otelOptions, (span) => {
                 try {
                     const result = originalFunction.apply(this, args);
-                    if (result &&
-                        typeof result.then === "function" &&
-                        typeof result.catch === "function") {
+                    if (result instanceof Promise) {
                         return result
                             .then((res) => {
                             handleOnResult(span, onResult, res);

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

@@ -40,6 +40,20 @@ class TestSpan {
     errorInOnResult() {
         return "success";
     }
+    async asyncError() {
+        throw new Error("async hello world");
+    }
+    lastLazyThenable;
+    returnsLazyThenable() {
+        this.lastLazyThenable = makeLazyThenable("lazy result");
+        return this.lastLazyThenable;
+    }
+    returnsFailingLazyThenable() {
+        return makeFailingLazyThenable(new Error("lazy rejection"));
+    }
+    lazyThenableOnResult() {
+        return makeLazyThenable({ rows: [1, 2, 3] });
+    }
 }
 __decorate([
     (0, span_1.Span)(),
@@ -122,6 +136,72 @@ __decorate([
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
 ], TestSpan.prototype, "errorInOnResult", null);
+__decorate([
+    (0, span_1.Span)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TestSpan.prototype, "asyncError", null);
+__decorate([
+    (0, span_1.Span)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestSpan.prototype, "returnsLazyThenable", null);
+__decorate([
+    (0, span_1.Span)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestSpan.prototype, "returnsFailingLazyThenable", null);
+__decorate([
+    (0, span_1.Span)({
+        onResult: (_result) => ({ attributes: { count: _result.rows.length } }),
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], TestSpan.prototype, "lazyThenableOnResult", null);
+function makeLazyThenable(value) {
+    const thenable = {
+        triggered: false,
+        // biome-ignore lint/suspicious/noThenProperty: <We are testing the behavior of the thenable>
+        then(onFulfilled, onRejected) {
+            thenable.triggered = true;
+            try {
+                const result = onFulfilled ? onFulfilled(value) : value;
+                return Promise.resolve(result);
+            }
+            catch (error) {
+                if (onRejected) {
+                    return Promise.resolve(onRejected(error));
+                }
+                return Promise.reject(error);
+            }
+        },
+        catch(onRejected) {
+            return thenable.then(undefined, onRejected);
+        },
+    };
+    return thenable;
+}
+function makeFailingLazyThenable(error) {
+    const thenable = {
+        triggered: false,
+        // biome-ignore lint/suspicious/noThenProperty: <We are testing the behavior of the thenable>
+        then(_onFulfilled, onRejected) {
+            thenable.triggered = true;
+            if (onRejected) {
+                return Promise.resolve(onRejected(error));
+            }
+            return Promise.reject(error);
+        },
+        catch(onRejected) {
+            return thenable.then(undefined, onRejected);
+        },
+    };
+    return thenable;
+}
 describe("Span", () => {
     let instance;
     let traceExporter;
@@ -249,4 +329,71 @@ describe("Span", () => {
         expect(spans[0].events).toHaveLength(1);
         expect(spans[0].events[0].name).toBe("exception");
     });
+    it("should call onResult with the thenable (not resolved value) for lazy thenables", () => {
+        // The decorator hands the lazy thenable to onResult untouched (it cannot
+        // know it is a deferred query). Accessing fields on the resolved shape
+        // (e.g. `.rows`) therefore throws synchronously, and the decorator records
+        // that as an exception on the span.
+        const returned = instance.lazyThenableOnResult();
+        // Caller still receives the untouched thenable.
+        expect(returned.triggered).toBe(false);
+        const spans = traceExporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans[0].status.code).toBe(api_1.SpanStatusCode.ERROR);
+        expect(spans[0].status.message).toMatch("Cannot read properties of undefined (reading 'length')");
+        expect(spans[0].events).toHaveLength(1);
+        expect(spans[0].events[0].name).toBe("exception");
+        expect(spans[0].events[0].attributes?.["exception.type"]).toBe("TypeError");
+    });
+    it("should not trigger a lazy thenable returned by the wrapped method", () => {
+        const returned = instance.returnsLazyThenable();
+        // The decorator must hand the lazy thenable back to the caller untouched.
+        // It must NOT subscribe via .then(), which would force-execute query
+        // builders such as Knex, Mongoose Query, or Drizzle queries that the
+        // caller intended to defer (or compose further) before awaiting.
+        expect(instance.lastLazyThenable?.triggered).toBe(false);
+        expect(returned).toBe(instance.lastLazyThenable);
+    });
+    it("should end the span synchronously before the caller awaits a lazy thenable", () => {
+        instance.returnsLazyThenable();
+        // The span closes as soon as the decorated method returns, before the
+        // caller subscribes to the thenable, because the decorator cannot know
+        // whether the caller will compose it further or await it at all.
+        const spans = traceExporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans[0].name).toBe("TestSpan.returnsLazyThenable");
+    });
+    it("should not record errors from a lazy thenable that rejects after the span has ended", async () => {
+        const returned = instance.returnsFailingLazyThenable();
+        // Span is already closed — no error recorded yet.
+        const spans = traceExporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans[0].status.code).toBe(api_1.SpanStatusCode.UNSET);
+        expect(spans[0].events).toHaveLength(0);
+        // Caller awaits the thenable now — it rejects — but the span is gone.
+        await expect(Promise.resolve(returned)).rejects.toThrow("lazy rejection");
+        // Known limitation: the rejection is invisible to the span.
+        expect(traceExporter.getFinishedSpans()[0].events).toHaveLength(0);
+    });
+    it("should still track results from async (real Promise) methods", async () => {
+        const result = await instance.asyncMethod();
+        expect(result).toBe("async success");
+        const spans = traceExporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans[0].name).toBe("TestSpan.asyncMethod");
+        expect(spans[0].status.code).toBe(api_1.SpanStatusCode.UNSET);
+        expect(spans[0].attributes).toEqual({ result: "async success" });
+    });
+    it("should still track errors thrown by async (real Promise) methods", async () => {
+        await expect(instance.asyncError()).rejects.toThrow("async hello world");
+        const spans = traceExporter.getFinishedSpans();
+        expect(spans).toHaveLength(1);
+        expect(spans[0].name).toBe("TestSpan.asyncError");
+        expect(spans[0].status).toEqual({
+            code: api_1.SpanStatusCode.ERROR,
+            message: "async hello world",
+        });
+        expect(spans[0].events).toHaveLength(1);
+        expect(spans[0].events[0].name).toBe("exception");
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-otel",
-  "version": "8.0.2",
+  "version": "8.0.3",
   "description": "NestJS OpenTelemetry Library",
   "main": "lib/index.js",
   "typings": "lib/index",