plutin 1.5.4 → 1.6.1

package/dist/index.cjs

@@ -457,10 +457,13 @@ __export(src_exports, {
   NotificationErrorInMemory: () => NotificationErrorInMemory,
   NotificationFactory: () => NotificationFactory,
   SentryNotifier: () => SentryNotifier,
+  Span: () => Span,
+  TracerGatewayOpentelemetry: () => TracerGatewayOpentelemetry,
   UniqueEntityId: () => UniqueEntityId,
   UniqueObjectId: () => UniqueObjectId,
   ValueObject: () => ValueObject,
   WatchedList: () => WatchedList,
+  WinstonOtelFastify: () => WinstonOtelFastify,
   baseEnvSchema: () => baseEnvSchema,
   getTakeAndSkip: () => getTakeAndSkip,
   logger: () => logger,
@@ -1504,6 +1507,198 @@ function zodValidator(schema) {
 }
 __name(zodValidator, "zodValidator");
 
+// src/infra/adapters/logger/winston-otel-fastify.ts
+var import_api = __toESM(require("@opentelemetry/api"), 1);
+var import_api_logs = require("@opentelemetry/api-logs");
+var import_winston = __toESM(require("winston"), 1);
+var WinstonOtelFastify = class WinstonOtelFastify2 {
+  static {
+    __name(this, "WinstonOtelFastify");
+  }
+  env;
+  logger;
+  consoleLogger;
+  level;
+  constructor(env) {
+    this.env = env;
+    this.level = "info";
+    if (env.OTEL_ENABLE) {
+      this.logger = import_api_logs.logs.getLogger(this.env.OTEL_SERVICE_NAME, this.env.OTEL_SERVICE_VERSION);
+      this.level = this.env.LOG_LEVEL;
+      const transports = this.env.NODE_ENV === "test" ? [
+        new import_winston.default.transports.Console({
+          silent: true
+        })
+      ] : [
+        new import_winston.default.transports.Console()
+      ];
+      this.consoleLogger = import_winston.default.createLogger({
+        level: this.level,
+        format: import_winston.default.format.combine(import_winston.default.format.timestamp({
+          format: "YYYY-MM-DD HH:mm:ss:ms"
+        }), import_winston.default.format((info) => {
+          if (this.env.NODE_ENV !== "test") {
+            const span = import_api.default.trace.getActiveSpan();
+            if (span) {
+              info.spanId = span.spanContext().spanId;
+              info.traceId = span.spanContext().traceId;
+            }
+          }
+          return info;
+        })(), import_winston.default.format.json()),
+        transports
+      });
+    } else {
+      this.consoleLogger = import_winston.default.createLogger({
+        level: this.level,
+        format: import_winston.default.format.combine(import_winston.default.format.timestamp({
+          format: "YYYY-MM-DD HH:mm:ss:ms"
+        }), import_winston.default.format.json())
+      });
+    }
+  }
+  bodyIsFastifyRequest(body) {
+    return body.method !== void 0;
+  }
+  bodyIsFastifyReply(body) {
+    return body.statusCode !== void 0;
+  }
+  buildMessage(body) {
+    if (typeof body === "object" && body.req && this.bodyIsFastifyRequest(body.req)) {
+      return `${body.req.method} ${body.req.url}`;
+    } else if (typeof body === "object" && body.res && this.bodyIsFastifyReply(body.res)) {
+      return `${body.res.request.method} ${body.res.request.url} ${body.res.statusCode} - ${body.res.elapsedTime} ms`;
+    } else if (typeof body === "string") {
+      return body;
+    } else {
+      return "";
+    }
+  }
+  logMessage(body, severityNumber, severityText) {
+    const message = this.buildMessage(body);
+    this.consoleLogger[severityText.toLowerCase()](message);
+    if (this.env.NODE_ENV !== "test") {
+      this.logger.emit({
+        body: message,
+        severityNumber,
+        severityText
+      });
+    }
+  }
+  info(body) {
+    this.logMessage(body, import_api_logs.SeverityNumber.INFO, "INFO");
+  }
+  error(body) {
+    this.logMessage(body, import_api_logs.SeverityNumber.ERROR, "ERROR");
+  }
+  debug(body) {
+    this.logMessage(body, import_api_logs.SeverityNumber.DEBUG, "DEBUG");
+  }
+  fatal(body) {
+    this.logMessage(body, import_api_logs.SeverityNumber.FATAL, "FATAL");
+  }
+  warn(body) {
+    this.logMessage(body, import_api_logs.SeverityNumber.WARN, "WARN");
+  }
+  trace(message) {
+    if (this.env.NODE_ENV !== "test") {
+      this.logger.emit({
+        body: message,
+        severityNumber: import_api_logs.SeverityNumber.TRACE,
+        severityText: "TRACE"
+      });
+    }
+  }
+  child() {
+    return new WinstonOtelFastify2(process.env);
+  }
+};
+
+// src/infra/adapters/observability/otel/span-decorator.ts
+var import_api2 = __toESM(require("@opentelemetry/api"), 1);
+var import_reflect_metadata4 = require("reflect-metadata");
+function Span() {
+  return function(target, propertyKey, descriptor) {
+    if (!process.env.OTEL_ENABLE) {
+      return descriptor;
+    }
+    const originalMethod = descriptor.value;
+    descriptor.value = function(...args) {
+      const tracer = import_api2.default.trace.getTracer(process.env.OTEL_SERVICE_NAME, process.env.OTEL_SERVICE_VERSION);
+      const className = target.constructor?.name || "UnknownClass";
+      const methodName = String(propertyKey);
+      const spanName = `${className}.${methodName}`;
+      return tracer.startActiveSpan(spanName, async (span) => {
+        try {
+          const result = originalMethod.apply(this, args);
+          if (result instanceof Promise) {
+            try {
+              const awaitedResult = await result;
+              span.addEvent(`Method [${methodName}] executed successfully`);
+              span.end();
+              return awaitedResult;
+            } catch (error) {
+              handleSpanError(span, error);
+              throw error;
+            }
+          } else {
+            span.addEvent(`Method [${methodName}] executed successfully`);
+            span.end();
+            return result;
+          }
+        } catch (error) {
+          handleSpanError(span, error);
+          throw error;
+        }
+      });
+    };
+    return descriptor;
+  };
+}
+__name(Span, "Span");
+function handleSpanError(span, error) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (error instanceof Error) {
+    span.recordException(error);
+  } else {
+    span.recordException(new Error(String(error)));
+  }
+  span.setStatus({
+    code: import_api2.SpanStatusCode.ERROR,
+    message: errorMessage
+  });
+  span.end();
+}
+__name(handleSpanError, "handleSpanError");
+
+// src/infra/adapters/observability/otel/tracer-gateway-opentelemetry.ts
+var import_api3 = __toESM(require("@opentelemetry/api"), 1);
+var TracerGatewayOpentelemetry = class {
+  static {
+    __name(this, "TracerGatewayOpentelemetry");
+  }
+  addEvent(name, attributes) {
+    if (!process.env.OTEL_ENABLE) {
+      return;
+    }
+    const span = import_api3.default.trace.getActiveSpan();
+    if (span && attributes) {
+      span.addEvent(name, attributes);
+    } else if (span) {
+      span.addEvent(name);
+    }
+  }
+  setAttribute(key, value) {
+    if (!process.env.OTEL_ENABLE) {
+      return;
+    }
+    const span = import_api3.default.trace.getActiveSpan();
+    if (span) {
+      span.setAttribute(key, value);
+    }
+  }
+};
+
 // src/infra/env/index.ts
 var import_zod = require("zod");
 
@@ -1528,7 +1723,20 @@ var baseEnvSchema = import_zod.z.object({
   PORT: import_zod.z.coerce.number().default(3333),
   SHOULD_NOTIFY_ERROR: import_zod.z.coerce.boolean().default(true),
   SENTRY_DSN: import_zod.z.string().optional(),
-  DISCORD_WEBHOOK_URL: import_zod.z.string().optional()
+  DISCORD_WEBHOOK_URL: import_zod.z.string().optional(),
+  LOG_LEVEL: import_zod.z.enum([
+    "info",
+    "error",
+    "debug",
+    "fatal",
+    "warn"
+  ]).default("info"),
+  OTEL_ENABLE: import_zod.z.coerce.boolean().default(false),
+  OTEL_SERVICE_NAME: import_zod.z.string().optional(),
+  OTEL_SERVICE_VERSION: import_zod.z.string().optional(),
+  OTEL_OTLP_TRACES_EXPORTER_URL: import_zod.z.string().url().optional(),
+  OTEL_OTLP_LOGS_EXPORTER_URL: import_zod.z.string().url().optional(),
+  OTEL_OTLP_METRICS_EXPORTER_URL: import_zod.z.string().url().optional()
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1547,10 +1755,13 @@ var baseEnvSchema = import_zod.z.object({
   NotificationErrorInMemory,
   NotificationFactory,
   SentryNotifier,
+  Span,
+  TracerGatewayOpentelemetry,
   UniqueEntityId,
   UniqueObjectId,
   ValueObject,
   WatchedList,
+  WinstonOtelFastify,
   baseEnvSchema,
   getTakeAndSkip,
   logger,