@ryanzeng/nest-observe 0.1.3 → 0.1.5

package/dist/index.mjs

@@ -296,6 +296,71 @@ function bodyValue(message) {
     return redactText(message.stack ?? `${message.name}: ${message.message}`);
   return redact(message);
 }
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null) return true;
+  const constructor = Object.prototype.hasOwnProperty.call(prototype, "constructor") ? prototype.constructor : void 0;
+  return typeof constructor === "function" && constructor instanceof constructor && Function.prototype.toString.call(constructor) === Function.prototype.toString.call(Object);
+}
+function isStackFormat(value) {
+  return typeof value === "string" && /^(.)+\n\s+at .+:\d+:\d+/.test(value);
+}
+function fallbackMessages(logger, values) {
+  if (values.length <= 1) return { messages: values, context: logger.context };
+  const lastValue = values.at(-1);
+  const contextName = typeof lastValue === "string" ? lastValue : logger.context;
+  const remaining = typeof lastValue === "string" ? values.slice(0, -1) : values;
+  if (logger.options?.structuredParams === false) {
+    return { messages: remaining, context: contextName };
+  }
+  const messages = [remaining[0]];
+  const structuredParams = [];
+  for (const value of remaining.slice(1)) {
+    if (isPlainObject(value)) structuredParams.push(value);
+    else messages.push(value);
+  }
+  const params = structuredParams.length > 0 ? Object.assign({}, ...structuredParams) : void 0;
+  return { messages, context: contextName, ...params ? { params } : {} };
+}
+function fallbackError(logger, values) {
+  if (values.length === 2) {
+    if (isStackFormat(values[1])) {
+      return { messages: [values[0]], stack: values[1], context: logger.context };
+    }
+    return fallbackMessages(logger, values);
+  }
+  const trailingValue = values.at(-1);
+  if (isStackFormat(trailingValue)) {
+    return { ...fallbackMessages(logger, values.slice(0, -1)), stack: trailingValue };
+  }
+  const parsed = fallbackMessages(logger, values);
+  if (parsed.messages.length <= 1) return parsed;
+  const possibleStack = parsed.messages.at(-1);
+  if (typeof possibleStack !== "string" && possibleStack !== void 0) return parsed;
+  return {
+    ...parsed,
+    messages: parsed.messages.slice(0, -1),
+    ...possibleStack === void 0 ? {} : { stack: possibleStack }
+  };
+}
+function parseLogCall(logger, method, message, args) {
+  const values = [message, ...args];
+  const nestParser = method === "error" ? logger.getContextAndStackAndMessagesToPrint : logger.getContextAndMessagesToPrint;
+  if (typeof nestParser === "function") return nestParser.call(logger, values);
+  return method === "error" ? fallbackError(logger, values) : fallbackMessages(logger, values);
+}
+function exceptionAttributes(message, stack) {
+  const error = message instanceof Error ? message : void 0;
+  const stacktrace = stack ?? error?.stack;
+  return {
+    ...error ? {
+      "exception.type": error.name,
+      "exception.message": redactText(error.message)
+    } : {},
+    ...stacktrace ? { "exception.stacktrace": redactText(stacktrace) } : {}
+  };
+}
 var NestLoggerInstrumentation = class {
   constructor(emitter, resourceAttributes = {}) {
     this.emitter = emitter;
@@ -317,18 +382,30 @@ var NestLoggerInstrumentation = class {
       const resourceAttributes = this.resourceAttributes;
       prototype[method] = function(message, ...args) {
         try {
+          const gated = this;
+          if (typeof gated.isLevelEnabled === "function" && !gated.isLevelEnabled(method)) {
+            return original.call(this, message, ...args);
+          }
           const spanContext = trace2.getActiveSpan()?.spanContext();
-          const contextName = this.context ?? (typeof args.at(-1) === "string" ? String(args.at(-1)) : void 0);
-          const attributes = { ...resourceAttributes };
-          if (contextName) attributes["nestjs.context"] = contextName;
-          if (spanContext?.traceId) attributes.trace_id = spanContext.traceId;
-          if (spanContext?.spanId) attributes.span_id = spanContext.spanId;
-          emitter.emit({
-            body: bodyValue(message),
-            severityText: SEVERITY[method],
-            attributes,
-            timestamp: Date.now()
-          });
+          const parsed = parseLogCall(this, method, message, args);
+          const timestamp = Date.now();
+          for (const parsedMessage of parsed.messages) {
+            const params = parsed.params ? redact(parsed.params) : {};
+            const attributes = {
+              ...params,
+              ...resourceAttributes,
+              ...exceptionAttributes(parsedMessage, parsed.stack)
+            };
+            if (parsed.context) attributes["nestjs.context"] = parsed.context;
+            if (spanContext?.traceId) attributes.trace_id = spanContext.traceId;
+            if (spanContext?.spanId) attributes.span_id = spanContext.spanId;
+            emitter.emit({
+              body: bodyValue(parsedMessage),
+              severityText: SEVERITY[method],
+              attributes,
+              timestamp
+            });
+          }
         } catch {
         }
         return original.call(this, message, ...args);
@@ -654,7 +731,6 @@ import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
 import { registerInstrumentations } from "@opentelemetry/instrumentation";
 import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
-import { PrismaInstrumentation } from "@prisma/instrumentation";
 import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
 import { AggregationType, MeterProvider, PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
 import { AlwaysOffSampler, BatchSpanProcessor, ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
@@ -823,7 +899,7 @@ import { hostname } from "os";
 // package.json
 var package_default = {
   name: "@ryanzeng/nest-observe",
-  version: "0.1.3",
+  version: "0.1.4",
   description: "Zero-config, vendor-neutral OpenTelemetry observability for NestJS",
   keywords: [
     "nestjs",
@@ -908,8 +984,7 @@ var package_default = {
     "@opentelemetry/sdk-logs": "^0.221.0",
     "@opentelemetry/sdk-metrics": "^2.10.0",
     "@opentelemetry/sdk-trace-base": "^2.10.0",
-    "@opentelemetry/sdk-trace-node": "^2.10.0",
-    "@prisma/instrumentation": "^7.10.0"
+    "@opentelemetry/sdk-trace-node": "^2.10.0"
   },
   devDependencies: {
     "@nestjs/common": "^12.0.1",
@@ -1224,7 +1299,6 @@ function observe(options = {}) {
         providerTracing: config.providerTracing,
         controllerTracing: config.controllerTracing
       }));
-      if (config.traces) instrumentations.push(new PrismaInstrumentation());
       registerInstrumentations({
         instrumentations,
         ...tracerProvider ? { tracerProvider } : {},