@bymax-one/nest-logger 1.2.0 → 1.2.1

package/dist/server/index.cjs

@@ -65,6 +65,14 @@ function applyDefaults(options) {
     shouldUseAsNestLogger: options.shouldUseAsNestLogger ?? true,
     redactPaths: Object.freeze([...options.redactPaths ?? []]),
     redactStrategy: options.redactStrategy ?? "names",
+    // `'nested'` keeps the shape every existing consumer already queries.
+    resourceFormat: options.resourceFormat ?? "nested",
+    // `??` rather than `||`: `false` is a meaningful value here (emit nothing)
+    // and `||` would silently replace it with the default.
+    eventNameField: options.eventNameField ?? "event.name",
+    // `'pino'` by default: the semconv attributes are additive value, but the
+    // legacy shape is what existing dashboards and alerts already query.
+    errorFormat: options.errorFormat ?? "pino",
     redactCensor: options.redactCensor ?? "[REDACTED]",
     shouldDisableDefaultRedact: options.shouldDisableDefaultRedact ?? false,
     destinations: Object.freeze([...options.destinations ?? []]),
@@ -134,6 +142,27 @@ function validateOptions(options) {
       )}`
     );
   }
+  if (options.resourceFormat !== void 0 && options.resourceFormat !== "nested" && options.resourceFormat !== "flat") {
+    throw new Error(
+      `[BymaxLoggerModule] options.resourceFormat must be 'nested' or 'flat'. Got: ${String(
+        options.resourceFormat
+      )}`
+    );
+  }
+  if (options.errorFormat !== void 0 && options.errorFormat !== "pino" && options.errorFormat !== "semconv" && options.errorFormat !== "both") {
+    throw new Error(
+      `[BymaxLoggerModule] options.errorFormat must be 'pino', 'semconv' or 'both'. Got: ${String(
+        options.errorFormat
+      )}`
+    );
+  }
+  if (options.eventNameField !== void 0 && options.eventNameField !== false && (typeof options.eventNameField !== "string" || options.eventNameField.length === 0)) {
+    throw new Error(
+      `[BymaxLoggerModule] options.eventNameField must be a non-empty string or false. Got: ${String(
+        options.eventNameField
+      )}`
+    );
+  }
 }
 
 // src/server/constants/injection-tokens.constants.ts
@@ -183,6 +212,23 @@ var PROTOTYPE_POLLUTING_KEYS = /* @__PURE__ */ new Set([
   "prototype"
 ]);
 
+// src/server/utils/escape-log-text.util.ts
+var LINE_TERMINATORS = /* @__PURE__ */ new Set(["\r", "\n", "\x85", "\u2028", "\u2029"]);
+var UNSAFE_IN_SINGLE_LINE = /[\u0000-\u0008\u000A-\u001F\u007F-\u009F\u2028\u2029]/g;
+var UNSAFE_IN_MULTILINE = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F\u2028\u2029]/g;
+function toEscapeSequence(char) {
+  return `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`;
+}
+function toSingleLineMessage(text) {
+  return text.replace(
+    UNSAFE_IN_SINGLE_LINE,
+    (char) => LINE_TERMINATORS.has(char) ? "\\n" : toEscapeSequence(char)
+  );
+}
+function escapeControlCharacters(text) {
+  return text.replace(UNSAFE_IN_MULTILINE, toEscapeSequence);
+}
+
 // src/server/services/pino-logger.service.ts
 var OWNED_PAYLOAD_KEYS = ["logKey", "userId", "context"];
 function withoutOwnedKeys(metadata) {
@@ -206,7 +252,7 @@ function withoutOwnedKeys(metadata) {
 }
 function safeErrorMessage(error) {
   try {
-    return String(error.message);
+    return toSingleLineMessage(String(error.message));
   } catch {
     return "Unreadable error message";
   }
@@ -248,7 +294,7 @@ exports.PinoLoggerService = class PinoLoggerService {
    */
   error(message, ...optionalParams) {
     if (message instanceof Error) {
-      const payload2 = { err: this.serializeError(message) };
+      const payload2 = { err: message };
       assignIfDefined(payload2, "context", this.resolveContext(optionalParams));
       this.pino.error(payload2, safeErrorMessage(message));
       return;
@@ -258,7 +304,10 @@ exports.PinoLoggerService = class PinoLoggerService {
     const payload = {};
     assignIfDefined(payload, "context", context);
     assignIfDefined(payload, "stack", stack);
-    this.pino.error(payload, typeof message === "string" ? message : String(message));
+    this.pino.error(
+      payload,
+      toSingleLineMessage(typeof message === "string" ? message : String(message))
+    );
   }
   /**
    * NestJS `warn` (warn level).
@@ -335,7 +384,12 @@ exports.PinoLoggerService = class PinoLoggerService {
     const payload = {
       ...withoutOwnedKeys(metadata),
       logKey,
-      err: this.serializeError(error)
+      // The RAW value, not a pre-serialized copy. Pre-serializing was what let
+      // Pino's standard `err` serializer re-derive `type` from the resulting
+      // plain object's constructor and emit `"Object"` for every typed
+      // exception — and it discarded the cause chain on the way. The configured
+      // serializer owns the shape now.
+      err: error
     };
     assignIfDefined(payload, "userId", userId);
     assignIfDefined(payload, "context", this.context);
@@ -387,23 +441,6 @@ exports.PinoLoggerService = class PinoLoggerService {
   onApplicationShutdown() {
   }
   // ─── Private ──────────────────────────────────────────────────────────────
-  /**
-   * Serialize an Error into a plain, log-safe object matching Pino's built-in
-   * `err` serializer shape (`type`, `message`, `stack`).
-   *
-   * Reads `error.name` (NOT `error.constructor.name`) for `type`: native
-   * subclasses set `name` to their class name, and a sanitized plain-object error
-   * (from `sanitizeError`) carries the real class name on `name` — whereas its
-   * `constructor.name` would be the unhelpful `'Object'`, breaking `err.type`
-   * dashboards for every exception logged through `HttpExceptionFilter`.
-   */
-  serializeError(error) {
-    try {
-      return { type: error.name, message: error.message, stack: error.stack };
-    } catch {
-      return { type: "SanitizeFailed", message: "Failed to read the thrown value" };
-    }
-  }
   /** Resolve the context: last string param wins, else the instance context. */
   resolveContext(optionalParams) {
     const last = optionalParams[optionalParams.length - 1];
@@ -414,17 +451,18 @@ exports.PinoLoggerService = class PinoLoggerService {
     const payload = { ...withoutOwnedKeys(metadata), logKey };
     assignIfDefined(payload, "userId", userId);
     assignIfDefined(payload, "context", this.context);
+    const line = toSingleLineMessage(message);
     if (level === "info") {
-      this.pino.info(payload, message);
+      this.pino.info(payload, line);
     } else {
-      this.pino.warn(payload, message);
+      this.pino.warn(payload, line);
     }
   }
   /** Emit a NestJS-style variadic log, dispatching by level without computed indexing. */
   emitNestStyle(level, message, optionalParams) {
     const payload = {};
     assignIfDefined(payload, "context", this.resolveContext(optionalParams));
-    const msg = typeof message === "string" ? message : String(message);
+    const msg = toSingleLineMessage(typeof message === "string" ? message : String(message));
     switch (level) {
       case "info":
         this.pino.info(payload, msg);
@@ -519,9 +557,16 @@ function sanitizeError(err, options) {
   const maxCauseDepth = DEFAULT_MAX_CAUSE_DEPTH;
   return toSanitizedError(err, /* @__PURE__ */ new WeakSet(), 0, maxCauseDepth);
 }
+function isErrorLike(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const candidate = value;
+  return typeof candidate.name === "string" && typeof candidate.message === "string";
+}
 function toSanitizedError(value, seen, depth2, maxDepth) {
   try {
-    if (!(value instanceof Error)) {
+    if (!isErrorLike(value)) {
       return { name: "UnknownError", message: String(value) };
     }
     seen.add(value);
@@ -559,7 +604,9 @@ function readAggregatedErrors(value) {
   return Array.isArray(candidate) ? candidate : void 0;
 }
 function scrubStack(stack) {
-  return stack.split("\n").filter((line) => !line.includes("node_modules")).join("\n");
+  return escapeControlCharacters(
+    stack.split("\n").filter((line) => !line.includes("node_modules")).join("\n")
+  );
 }
 function isObject(value) {
   return typeof value === "object" && value !== null;
@@ -923,15 +970,18 @@ var DEFAULT_REDACT_PATHS = [
   ...REDACT_COMMON_FIELDS.flatMap((field) => depth(field)),
   ...REDACT_ABSOLUTE_PATHS
 ];
-function detectOtelTraceApi() {
+function loadTraceApiFrom(anchor) {
   try {
-    const requireFromCwd = module$1.createRequire(path.join(process.cwd(), "noop.cjs"));
-    const mod = requireFromCwd("@opentelemetry/api");
+    const requireFrom = module$1.createRequire(anchor());
+    const mod = requireFrom("@opentelemetry/api");
     return mod.trace;
   } catch {
     return void 0;
   }
 }
+function detectOtelTraceApi() {
+  return loadTraceApiFrom(() => __filename) ?? loadTraceApiFrom(() => path.join(process.cwd(), "noop.cjs"));
+}
 function isValidTraceId(traceId) {
   return /^[0-9a-f]{32}$/.test(traceId) && !/^0+$/.test(traceId);
 }
@@ -1127,6 +1177,127 @@ function createNameRedactor(fieldNames, censor) {
   };
 }
 
+// src/server/utils/resolve-resource.util.ts
+var ATTR_NAMESPACE = "service.namespace";
+var ATTR_VERSION = "service.version";
+var ATTR_NAME = "service.name";
+var ATTR_INSTANCE_ID = "service.instance.id";
+var ATTR_ENVIRONMENT = "deployment.environment.name";
+function parseResourceAttributes(raw) {
+  const parsed = {};
+  if (raw === void 0) {
+    return parsed;
+  }
+  for (const pair of raw.split(",")) {
+    const separator = pair.indexOf("=");
+    if (separator <= 0) {
+      continue;
+    }
+    const key = pair.slice(0, separator).trim();
+    const rawValue = pair.slice(separator + 1).trim();
+    if (rawValue.length === 0) {
+      continue;
+    }
+    let value;
+    try {
+      value = decodeURIComponent(rawValue);
+    } catch {
+      value = rawValue;
+    }
+    Object.defineProperty(parsed, key, { value, enumerable: true, configurable: true });
+  }
+  return parsed;
+}
+function attribute(attributes, key) {
+  const value = Object.hasOwn(attributes, key) ? Reflect.get(attributes, key) : void 0;
+  return typeof value === "string" ? value : void 0;
+}
+function firstNonEmpty(...candidates) {
+  const found = candidates.find(
+    (candidate) => typeof candidate === "string" && candidate.length > 0
+  );
+  return found;
+}
+function resolveServiceMetadata(service, env = process.env) {
+  const attributes = parseResourceAttributes(env["OTEL_RESOURCE_ATTRIBUTES"]);
+  const resolved = {
+    // The spec's precedence: OTEL_SERVICE_NAME beats service.name in the
+    // attribute list. Explicit configuration still beats both.
+    name: firstNonEmpty(service.name, env["OTEL_SERVICE_NAME"], attribute(attributes, ATTR_NAME)) ?? "",
+    version: firstNonEmpty(service.version, attribute(attributes, ATTR_VERSION)) ?? ""
+  };
+  const namespace = firstNonEmpty(service.namespace, attribute(attributes, ATTR_NAMESPACE));
+  if (namespace !== void 0) {
+    resolved.namespace = namespace;
+  }
+  const instanceId = firstNonEmpty(service.instanceId, attribute(attributes, ATTR_INSTANCE_ID));
+  if (instanceId !== void 0) {
+    resolved.instanceId = instanceId;
+  }
+  const environment = firstNonEmpty(
+    service.environment,
+    attribute(attributes, ATTR_ENVIRONMENT),
+    env["NODE_ENV"]
+  );
+  if (environment !== void 0) {
+    resolved.environment = environment;
+  }
+  return resolved;
+}
+function buildResourceBindings(resolved, format, extras = {}) {
+  if (format === "flat") {
+    const flat = {
+      [ATTR_NAME]: resolved.name,
+      [ATTR_VERSION]: resolved.version
+    };
+    for (const [key, value] of Object.entries(extras)) {
+      Reflect.set(flat, `service.${key}`, value);
+    }
+    if (resolved.namespace !== void 0) {
+      Reflect.set(flat, ATTR_NAMESPACE, resolved.namespace);
+    }
+    if (resolved.instanceId !== void 0) {
+      Reflect.set(flat, ATTR_INSTANCE_ID, resolved.instanceId);
+    }
+    if (resolved.environment !== void 0) {
+      Reflect.set(flat, ATTR_ENVIRONMENT, resolved.environment);
+    }
+    return flat;
+  }
+  const service = {
+    ...extras,
+    name: resolved.name,
+    version: resolved.version
+  };
+  if (resolved.namespace !== void 0) {
+    service["namespace"] = resolved.namespace;
+  }
+  if (resolved.instanceId !== void 0) {
+    service["instance"] = { id: resolved.instanceId };
+  }
+  const bindings = { service };
+  if (resolved.environment !== void 0) {
+    bindings["deployment"] = { environment: { name: resolved.environment } };
+  }
+  return bindings;
+}
+var OWNED_SERVICE_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "version",
+  "namespace",
+  "instanceId",
+  "environment"
+]);
+function extraServiceFields(service) {
+  const extras = {};
+  for (const [key, value] of Object.entries({ ...service })) {
+    if (!OWNED_SERVICE_KEYS.has(key)) {
+      Reflect.set(extras, key, value);
+    }
+  }
+  return extras;
+}
+
 // src/server/utils/truncate-large-entries.ts
 var PREVIEW_LENGTH = 200;
 function createSizeBoundedSerializer(baseSerializer, maxBytes) {
@@ -1168,6 +1339,85 @@ function leafNameOf(path) {
   }
   return leaf;
 }
+var DERIVED_ERROR_FIELDS = /* @__PURE__ */ new Set([
+  "name",
+  "message",
+  "stack",
+  "cause",
+  "errors"
+]);
+function serializeErrorValue(value_) {
+  const sanitized = sanitizeError(value_);
+  const serialized = {
+    // `type` rather than `name`: the field consumers already query.
+    type: sanitized.name,
+    message: sanitized.message
+  };
+  if (sanitized.stack !== void 0) {
+    serialized["stack"] = sanitized.stack;
+  }
+  if (sanitized.cause !== void 0) {
+    serialized["cause"] = sanitized.cause;
+  }
+  if (sanitized.errors !== void 0) {
+    serialized["errors"] = sanitized.errors;
+  }
+  try {
+    const source = (
+      // Stryker disable next-line ConditionalExpression: equivalent BY CONSTRUCTION, not untested — the never-throw catch below makes the mutant observationally identical: with the null check flipped to true, `Object.entries(null)` throws, the catch swallows it, and the emitted envelope is byte-for-byte the same. The guard stays because routing the ordinary null case through exception control flow would trade an explicit branch for a hidden one.
+      typeof value_ === "object" && value_ !== null && !Array.isArray(value_) ? value_ : {}
+    );
+    for (const [key, value] of Object.entries(source)) {
+      if (!Object.hasOwn(serialized, key) && !DERIVED_ERROR_FIELDS.has(key)) {
+        Reflect.set(serialized, key, value);
+      }
+    }
+  } catch {
+  }
+  return serialized;
+}
+function withSemconvException(record, format) {
+  if (format === "pino") {
+    return record;
+  }
+  try {
+    const candidate = record["err"];
+    if (typeof candidate?.name === "string") {
+      record["exception.type"] = candidate.name;
+      record["error.type"] = candidate.name;
+    }
+    if (typeof candidate?.message === "string") {
+      record["exception.message"] = candidate.message;
+    }
+    if (typeof candidate?.stack === "string") {
+      record["exception.stacktrace"] = scrubStack(candidate.stack);
+    }
+    if (format === "semconv") {
+      const withoutErr = {};
+      for (const [key, value] of Object.entries(record)) {
+        if (key !== "err") {
+          Reflect.set(withoutErr, key, value);
+        }
+      }
+      return withoutErr;
+    }
+  } catch {
+  }
+  return record;
+}
+function toEventName(logKey) {
+  return logKey.toLowerCase().replaceAll("_", ".");
+}
+function withEventName(record, field) {
+  if (field === false) {
+    return record;
+  }
+  const logKey = record["logKey"];
+  if (typeof logKey === "string" && logKey.length > 0) {
+    Reflect.set(record, field, toEventName(logKey));
+  }
+  return record;
+}
 var PASS_THROUGH = (value) => value;
 function resolveNameRedactor(options) {
   if (options.redactStrategy !== "names") {
@@ -1194,7 +1444,7 @@ function buildPinoInstance(options, logContext, destinations) {
   const redact = resolveNameRedactor(options);
   const bound = (serializer) => createSizeBoundedSerializer((input) => redact(serializer(input)), maxBytes);
   const serializers = {
-    err: bound(pino__default.default.stdSerializers.err),
+    err: bound(serializeErrorValue),
     ...Object.fromEntries(
       Object.entries(options.serializers).map(
         ([key, serializer]) => [key, bound(serializer)]
@@ -1205,7 +1455,14 @@ function buildPinoInstance(options, logContext, destinations) {
   const pinoOptions = {
     level: options.level,
     ...redactOption === void 0 ? {} : { redact: redactOption },
-    base: { service: options.service },
+    // Resource identity, resolved ONCE here rather than per entry: Pino
+    // pre-serializes `base` into the instance's chindings, so the cost of the
+    // extra attributes is one string built at construction, not work per log.
+    base: buildResourceBindings(
+      resolveServiceMetadata(options.service),
+      options.resourceFormat,
+      extraServiceFields(options.service)
+    ),
     // Pino requires the timestamp fn to emit the `,"time":"..."` fragment.
     timestamp: () => `,"time":"${options.timestamp()}"`,
     formatters: {
@@ -1228,7 +1485,10 @@ function buildPinoInstance(options, logContext, destinations) {
       // `base` and child bindings are NOT visible at this hook — they are
       // library-owned (`service`, the `@InjectLogger` context) and carry nothing
       // sensitive, which `pino-factory.spec.ts` pins.
-      log: (record) => redact(record, true)
+      log: (record) => withSemconvException(
+        withEventName(redact(record, true), options.eventNameField),
+        options.errorFormat
+      )
     },
     serializers,
     mixin: createTraceContextMixin(logContext, options.otel),
@@ -1327,6 +1587,14 @@ var DestinationRegistry = class {
         }
       );
     }
+    if (this.options.otel.shouldAutoInjectTraceContext && detectOtelTraceApi() === void 0) {
+      this.logger.warnStructured(
+        RESERVED_LOG_KEYS.LOGGER_BOOTSTRAP_WARNING,
+        "Trace-context auto-injection is enabled but @opentelemetry/api could not be resolved \u2014 traceId and spanId will be absent from every entry",
+        void 0,
+        { reason: "OTEL_API_UNAVAILABLE", shouldAutoInjectTraceContext: true }
+      );
+    }
   }
   /**
    * Flush and close active destinations in REVERSE registration order, so a
@@ -1705,8 +1973,9 @@ var HttpAccessLogMiddleware = class {
    *   `emitDecoratorMetadata`, so implicit class-type injection would not resolve.
    * @param options - Resolved module options (read for `http.excludePaths`).
    */
-  constructor(logger, options) {
+  constructor(logger, logContext, options) {
     this.logger = logger;
+    this.logContext = logContext;
     this.isEnabled = options.http.isEnabled;
     this.excludePaths = options.http.excludePaths;
   }
@@ -1745,12 +2014,17 @@ var HttpAccessLogMiddleware = class {
       ip: req.ip,
       userAgent: readUserAgent(req)
     });
-    res.on(
-      "close",
-      async_hooks.AsyncResource.bind(() => {
-        this.logTerminal(req, res, method, url, Date.now() - start);
-      })
-    );
+    const emitTerminal = () => {
+      this.logTerminal(req, res, method, url, Date.now() - start);
+    };
+    const bound = async_hooks.AsyncResource.bind(emitTerminal);
+    res.on("close", () => {
+      if (this.logContext.getStore() !== void 0) {
+        emitTerminal();
+      } else {
+        bound();
+      }
+    });
     next();
   }
   /**
@@ -1809,7 +2083,8 @@ var HttpAccessLogMiddleware = class {
 HttpAccessLogMiddleware = __decorateClass([
   common.Injectable(),
   __decorateParam(0, common.Inject(exports.PinoLoggerService)),
-  __decorateParam(1, common.Inject(LOGGER_OPTIONS_TOKEN))
+  __decorateParam(1, common.Inject(exports.LogContextService)),
+  __decorateParam(2, common.Inject(LOGGER_OPTIONS_TOKEN))
 ], HttpAccessLogMiddleware);
 var REQUEST_ID_HEADER = "x-request-id";
 var MAX_CORRELATION_ID_LENGTH = 256;

package/dist/server/index.d.cts

@@ -96,6 +96,79 @@ interface ServiceMetadata {
     readonly name: string;
     /** OTel attribute `service.version` — semver, commit SHA, or build tag. */
     readonly version: string;
+    /**
+     * OTel attribute `service.namespace` (**Stable**) — the group the service
+     * belongs to, e.g. a team, a bounded context or a tenant of the platform.
+     * Two services may share a `name` as long as their namespaces differ.
+     */
+    readonly namespace?: string;
+    /**
+     * OTel attribute `service.instance.id` (**Stable**) — identifies ONE running
+     * instance, so the triplet (namespace, name, instanceId) is globally unique.
+     *
+     * The library never generates this. A value minted here would be the logger's
+     * rather than the OpenTelemetry Resource's, so logs and traces would disagree
+     * about which instance served a request, and it would change on every restart
+     * while looking authoritative. Supply it from the platform — the Kubernetes
+     * pod UID, the ECS task ARN, the VM instance id — or through
+     * `OTEL_RESOURCE_ATTRIBUTES`, which is the same source the SDK reads.
+     *
+     * Treat it as HIGH cardinality: fine as a log field, not as a metric label.
+     */
+    readonly instanceId?: string;
+    /**
+     * OTel attribute `deployment.environment.name` (**Stable**) — `production`,
+     * `staging`, and so on. Falls back to `NODE_ENV` when omitted.
+     *
+     * The older `deployment.environment` spelling is **Deprecated** in the
+     * semantic conventions and is never emitted.
+     */
+    readonly environment?: string;
+}
+/**
+ * The `service` block as it appears in an EMITTED record, under the default
+ * `resourceFormat: 'nested'`.
+ *
+ * Distinct from {@link ServiceMetadata} on purpose, and the distinction is the
+ * kind of defect this library has already been bitten by once: a published type
+ * that describes something the runtime never emits. `ServiceMetadata` is what a
+ * consumer CONFIGURES — flat option names like `instanceId` and `environment`.
+ * What comes out is the flattened OTel attribute path: `service.instance.id`
+ * nests as `service: { instance: { id } }`, and the environment is not under
+ * `service` at all, it is `deployment.environment.name`. Typing the emitted
+ * record with the configuration interface would advertise `entry.service.instanceId`
+ * to every consumer, and that property does not exist on any entry.
+ *
+ * Under `resourceFormat: 'flat'` these values appear as dotted top-level keys
+ * (`"service.instance.id"`), which {@link LogEntry}'s index signature already
+ * admits — a flat record simply has no `service` object.
+ */
+interface EmittedServiceResource {
+    /** OTel `service.name`. */
+    readonly name: string;
+    /** OTel `service.version`. */
+    readonly version: string;
+    /** OTel `service.namespace`, when resolved. */
+    readonly namespace?: string;
+    /** OTel `service.instance.id`, nested as the attribute path spells it. */
+    readonly instance?: {
+        readonly id: string;
+    };
+    /** Consumer-supplied extras carried through from the `service` option. */
+    readonly [key: string]: unknown;
+}
+/**
+ * The `deployment` block as it appears in an EMITTED record under
+ * `resourceFormat: 'nested'`, carrying `deployment.environment.name`.
+ *
+ * Absent entirely when no source resolved an environment. The deprecated
+ * `deployment.environment` spelling is never emitted.
+ */
+interface EmittedDeploymentResource {
+    /** OTel `deployment.environment.name`, flattened from its attribute path. */
+    readonly environment: {
+        readonly name: string;
+    };
 }
 
 /**
@@ -191,6 +264,52 @@ interface BymaxLoggerModuleOptions {
      *     path-matching semantics; expect it to be removed in a future major.
      */
     redactStrategy?: 'names' | 'paths';
+    /**
+     * Shape of the resource/service identity on every entry. Default `'nested'`.
+     *
+     *   - `'nested'` — `{ service: { name, version, namespace, instance: { id } },
+     *     deployment: { environment: { name } } }`. The historical shape, extended;
+     *     no existing query breaks.
+     *   - `'flat'` — the dotted OTel attribute names verbatim (`service.name`,
+     *     `service.instance.id`, `deployment.environment.name`), which is what a
+     *     collector mapping log fields onto resource attributes reads directly.
+     *
+     * Both carry the same values; only the key shape differs.
+     */
+    resourceFormat?: 'nested' | 'flat';
+    /**
+     * Field carrying the machine-readable event name, mirroring `logKey`.
+     * Default `'event.name'`; `false` emits nothing.
+     *
+     * `logKey` stays exactly as it is — this is additive, never a rename.
+     *
+     * The value is meant to be mapped onto the **`EventName`** field of the
+     * OpenTelemetry LogRecord, which is Stable in the Logs Data Model. Note that
+     * the same-named `event.name` *attribute* is Deprecated in the semantic
+     * conventions precisely because the value belongs in that top-level field
+     * instead; the key here is the JSON carrier, not an OTLP attribute. The name is
+     * configurable so a pipeline that maps a different key can use it.
+     *
+     * Keep event names LOW cardinality — `payment.failed`, not
+     * `payment.failed.918231781`. Identifiers belong in their own fields.
+     */
+    eventNameField?: string | false;
+    /**
+     * Shape of the error fields on an entry. Default `'pino'`.
+     *
+     *   - `'pino'`   — only the legacy `err` object (`type`, `message`, `stack`,
+     *     plus the `cause` chain). What every existing query reads.
+     *   - `'semconv'` — only the OpenTelemetry attributes: `exception.type`,
+     *     `exception.message`, `exception.stacktrace` and `error.type`. The `err`
+     *     object is removed, so this is an explicit migration, never a default.
+     *   - `'both'`    — both shapes on the same entry. Recommended while moving
+     *     dashboards over: nothing breaks, and the new fields are already there.
+     *
+     * All four attributes are **Stable** in Semantic Conventions v1.44.0.
+     * `error.type` carries the error's class name and is LOW cardinality by
+     * construction — never a message, never an identifier.
+     */
+    errorFormat?: 'pino' | 'semconv' | 'both';
     /** Censor string written in place of redacted values. Default: `[REDACTED]`. */
     redactCensor?: string;
     /** Disable default redact paths (use with caution). Default: false. */
@@ -598,17 +717,6 @@ declare class PinoLoggerService implements LoggerService, OnApplicationShutdown
      * this service has no additional teardown work.
      */
     onApplicationShutdown(): void;
-    /**
-     * Serialize an Error into a plain, log-safe object matching Pino's built-in
-     * `err` serializer shape (`type`, `message`, `stack`).
-     *
-     * Reads `error.name` (NOT `error.constructor.name`) for `type`: native
-     * subclasses set `name` to their class name, and a sanitized plain-object error
-     * (from `sanitizeError`) carries the real class name on `name` — whereas its
-     * `constructor.name` would be the unhelpful `'Object'`, breaking `err.type`
-     * dashboards for every exception logged through `HttpExceptionFilter`.
-     */
-    private serializeError;
     /** Resolve the context: last string param wins, else the instance context. */
     private resolveContext;
     /** Emit a structured payload at info or warn level. */
@@ -1179,8 +1287,14 @@ interface LogEntry {
     msg: string;
     /** Convention key — `MODULE_ACTION_RESULT` format. */
     logKey?: string;
-    /** Service metadata snapshot — see {@link ServiceMetadata}. */
-    service?: ServiceMetadata;
+    /**
+     * Service identity as EMITTED — see {@link EmittedServiceResource}. Not the
+     * configuration shape: `service.instance.id` nests, and the environment lives
+     * under `deployment`, not here.
+     */
+    service?: EmittedServiceResource;
+    /** Deployment identity as emitted — see {@link EmittedDeploymentResource}. */
+    deployment?: EmittedDeploymentResource;
     /** Optional NestJS context (typically the emitting class name). */
     context?: string;
     /** Optional correlation IDs propagated via AsyncLocalStorage. */