logixia 2.0.0 → 2.0.4

package/README.md

@@ -982,23 +982,33 @@ const incomingTraceId = extractTraceId(req, {
 ### Express / Fastify middleware
 
 ```typescript
-import { traceMiddleware } from 'logixia';
-
-// Zero-config — reads from traceparent / x-trace-id / x-request-id / x-correlation-id
-// and generates a UUID v4 if none is present. Sets X-Trace-Id on the response.
-app.use(traceMiddleware());
+import { createExpressContextMiddleware, createFastifyContextHook } from 'logixia';
+
+// Express: trace ID = first present header of traceIdHeader (default
+// DEFAULT_TRACE_HEADERS: traceparent, x-trace-id, x-request-id, x-correlation-id,
+// trace-id; traceparent is parsed to its 32-hex trace id), else request.id, else a
+// generated UUID. The ID is available via getCurrentTraceId() and is the logger's
+// top-level traceId for everything inside the request. No response header is set
+// unless you ask for one with responseHeader.
+app.use(createExpressContextMiddleware({ responseHeader: 'X-Trace-Id' }));
+
+// Fastify: same resolution; fastify's default counter ids ('req-1', ...) are never
+// used as trace IDs. Also shared with createFastifyPlugin() from 'logixia/middleware'.
+// traceIdHeader accepts a single name or a list; responseHeader works as above.
+fastify.addHook('onRequest', createFastifyContextHook());
+
+// Prefer full control? Wrap the request yourself:
+app.use((req, res, next) => {
+  const traceId =
+    extractTraceId(req, { header: DEFAULT_TRACE_HEADERS, query: ['traceId'] }) ?? generateTraceId();
+  res.setHeader('X-Trace-Id', traceId);
+  runWithTraceId(traceId, () => next());
+});
 
-// With custom config:
-app.use(
-  traceMiddleware({
-    enabled: true,
-    generator: () => `req_${crypto.randomUUID()}`,
-    extractor: {
-      header: ['x-trace-id', 'traceparent'],
-      query: ['traceId'],
-    },
-  })
-);
+// Request/response logging (separate from tracing) lives in 'logixia/middleware':
+//   app.use(createExpressMiddleware(logger));
+//   await fastify.register(createFastifyPlugin(logger));
+// NestJS: import { TraceMiddleware } from 'logixia/nest';
 
 // Service layer — no parameters needed, trace ID propagates automatically
 class OrderService {
@@ -1531,6 +1541,8 @@ const logger = new BrowserLogger({
 });
 ```
 
+Delivery failures (network errors and non-OK HTTP statuses) are counted in `failedFlushes` / `lastError` and passed to the optional `onError` callback. A throttled (at most one per minute) console report containing only the error name, HTTP status and endpoint host is printed everywhere except real browser pages, where it is silent by default; set `silent: true` or `silent: false` to override. Entries written to the transport from inside `onError` or while a report is printed are dropped (counted in `dropped`) to avoid feedback loops.
+
 **Cloudflare Workers** — see [`examples/cloudflare-worker/`](./examples/cloudflare-worker/) for a Worker that logs JSON, tags each request with `child({ requestId })` and flushes a `BrowserRemoteTransport` with `ctx.waitUntil()`. Pass `flushIntervalMs: 0` to the transport: Workers don't allow timers at global scope.
 
 The following utilities from the main package are also re-exported from `logixia/browser` (safe for non-Node runtimes):
@@ -1739,24 +1751,27 @@ interface TransportLogEntry {
 Query your in-memory log history without shipping to Elasticsearch, Datadog, or any external service. Useful in development and lightweight production setups:
 
 ```typescript
-import { SearchManager } from 'logixia';
+import { SearchManager } from 'logixia/search';
 
-const search = new SearchManager({ maxEntries: 10_000 });
+const search = new SearchManager({ maxIndexSize: 10_000 });
 
 // Index a batch of entries (from a file, database query, or any source)
-await search.index(logEntries);
-
-// Search by text query, level, and time range
-const results = await search.search({
-  query: 'payment failed',
-  level: 'error',
-  from: new Date('2025-01-01'),
-  to: new Date(),
-  limit: 50,
-});
-// → sorted by relevance, full metadata included
+await search.indexLogs(logEntries); // or: await search.indexLog(entry)
+
+// Search by text, with filters and options
+const results = await search.search(
+  'payment failed',
+  { levels: ['error'], timeRange: { start: new Date('2025-01-01'), end: new Date() } },
+  { limit: 50 }
+);
+// → sorted by relevance, each result is { log, score, ... }
+
+const nl = await search.naturalLanguageSearch('payment errors'); // plain-English query
+const trace = await search.correlateByTraceId('req-001'); // every log of one request
 ```
 
+The same code runs as [`examples/search-readme.ts`](examples/search-readme.ts).
+
 ---
 
 ## OpenTelemetry
@@ -1810,6 +1825,8 @@ const logger = createLogger({
 // trace↔log correlation. Buffers drain on close() — no loss on shutdown.
 ```
 
+Import it from `logixia` or `logixia/transports`. Ready-made configs (URL and auth headers) for Grafana Loki / Grafana Cloud, Axiom, Better Stack and a local OpenTelemetry Collector are in [docs/otlp-recipes.md](docs/otlp-recipes.md).
+
 ---
 
 ## Wide events / canonical log lines

package/dist/async-context-B05ArHgM.mjs

@@ -0,0 +1,134 @@
+import { n as resolveTraceHeaders, o as TraceContext, t as resolveRequestTraceId } from "./request-trace-C_fvIDv4.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+// src/context/async-context.ts
+/**
+* LogixiaContext — Zero-boilerplate AsyncLocalStorage context propagation.
+*
+* Lets every `logger.info()` call inside a context automatically pick up stored
+* fields (requestId, userId, tenantId, …) without passing them through every function.
+*
+* Works across `Promise.all`, `setTimeout`, and event emitters — anything that
+* inherits the async execution context.
+*
+* @example
+* ```ts
+* import { LogixiaContext } from 'logixia';
+*
+* // Wrap a request handler:
+* app.use((req, res, next) => {
+*   LogixiaContext.run({ requestId: req.id, userId: req.user?.id }, next);
+* });
+*
+* // Anywhere deeper in the call tree:
+* async function processOrder(orderId: string) {
+*   const ctx = LogixiaContext.get();  // { requestId, userId, orderId }
+*   logger.info('Processing order', { orderId, ...ctx });
+* }
+* ```
+*/
+const _storage = new AsyncLocalStorage();
+const LogixiaContext = {
+	/**
+	* Run `callback` inside an async context that carries `store` fields.
+	* All loggers queried within `callback` (and its async descendants) will
+	* automatically see these fields.
+	*
+	* @example
+	* ```ts
+	* LogixiaContext.run({ requestId: 'abc', userId: '42' }, async () => {
+	*   await processOrder();   // sees requestId + userId in every log
+	* });
+	* ```
+	*/
+	run(store, callback) {
+		const parent = _storage.getStore() ?? {};
+		const scoped = () => _storage.run({
+			...parent,
+			...store
+		}, callback);
+		const traceId = store.traceId;
+		if (typeof traceId !== "string" || traceId === "") return scoped();
+		const trace = TraceContext.instance;
+		return trace.storage.run({
+			...trace.storage.getStore(),
+			[trace.contextKey]: traceId
+		}, scoped);
+	},
+	/**
+	* Return the context fields active in the current async scope.
+	* Returns `undefined` when called outside any `LogixiaContext.run()`.
+	*/
+	get() {
+		return _storage.getStore();
+	},
+	/**
+	* Merge `fields` into the **existing** context for the current scope.
+	* If called outside a `run()` context this is a no-op (logs a dev warning).
+	*/
+	set(fields) {
+		const store = _storage.getStore();
+		if (!store) return;
+		for (const key of Object.keys(fields)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			store[key] = fields[key];
+		}
+	},
+	/**
+	* Retrieve the underlying `AsyncLocalStorage` instance.
+	* Useful for advanced use-cases like custom middleware.
+	*/
+	getStorage() {
+		return _storage;
+	}
+};
+function buildScope(request, options, headers) {
+	return {
+		...options.enrich ? options.enrich(request) : {},
+		traceId: resolveRequestTraceId(request, headers)
+	};
+}
+/**
+* Create an Express/Connect-compatible middleware that wraps each request in
+* a `LogixiaContext.run()` scope populated with common request fields.
+*
+* Trace ID: the first present header of `traceIdHeader` (default
+* `DEFAULT_TRACE_HEADERS`, `traceparent` parsed), else `request.id`, else a
+* generated UUID. It is available via `getCurrentTraceId()` and is the logger's
+* top-level `traceId` inside the request. No response header is set unless
+* `responseHeader` is given.
+*
+* @example
+* ```ts
+* import { createExpressContextMiddleware } from 'logixia';
+* app.use(createExpressContextMiddleware({ responseHeader: 'x-trace-id' }));
+* ```
+*/
+function createExpressContextMiddleware(options = {}) {
+	const headers = resolveTraceHeaders(options.traceIdHeader);
+	return function logixiaContextMiddleware(req, res, next) {
+		var _res$setHeader;
+		const scope = buildScope(req, options, headers);
+		if (options.responseHeader) (_res$setHeader = res.setHeader) === null || _res$setHeader === void 0 || _res$setHeader.call(res, options.responseHeader, scope.traceId);
+		LogixiaContext.run(scope, next);
+	};
+}
+/**
+* Create a Fastify lifecycle hook that wraps each request in a context scope.
+*
+* Register with `fastify.addHook('onRequest', createFastifyContextHook())`.
+* Resolves the trace ID exactly like {@link createExpressContextMiddleware} and
+* shares it with `createFastifyPlugin()` from `logixia/middleware`. Fastify's
+* default counter `request.id` (`req-1`, ...) is never used as a trace ID.
+*/
+function createFastifyContextHook(options = {}) {
+	const headers = resolveTraceHeaders(options.traceIdHeader);
+	return function logixiaFastifyHook(request, reply, done) {
+		var _reply$header;
+		const scope = buildScope(request, options, headers);
+		if (options.responseHeader) (_reply$header = reply.header) === null || _reply$header === void 0 || _reply$header.call(reply, options.responseHeader, scope.traceId);
+		LogixiaContext.run(scope, done);
+	};
+}
+export { createExpressContextMiddleware as n, createFastifyContextHook as r, LogixiaContext as t };
+
+//# sourceMappingURL=async-context-B05ArHgM.mjs.map

package/dist/async-context-B05ArHgM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context-B05ArHgM.mjs","names":[],"sources":["../src/context/async-context.ts"],"sourcesContent":["/**\n * LogixiaContext — Zero-boilerplate AsyncLocalStorage context propagation.\n *\n * Lets every `logger.info()` call inside a context automatically pick up stored\n * fields (requestId, userId, tenantId, …) without passing them through every function.\n *\n * Works across `Promise.all`, `setTimeout`, and event emitters — anything that\n * inherits the async execution context.\n *\n * @example\n * ```ts\n * import { LogixiaContext } from 'logixia';\n *\n * // Wrap a request handler:\n * app.use((req, res, next) => {\n *   LogixiaContext.run({ requestId: req.id, userId: req.user?.id }, next);\n * });\n *\n * // Anywhere deeper in the call tree:\n * async function processOrder(orderId: string) {\n *   const ctx = LogixiaContext.get();  // { requestId, userId, orderId }\n *   logger.info('Processing order', { orderId, ...ctx });\n * }\n * ```\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\n\nimport {\n  type ContextRequestLike,\n  resolveRequestTraceId,\n  resolveTraceHeaders,\n  type TraceHeaderOption,\n} from '../utils/request-trace';\nimport { TraceContext } from '../utils/trace.utils';\n\nexport interface LogContext {\n  traceId?: string;\n  spanId?: string;\n  userId?: string;\n  tenantId?: string;\n  sessionId?: string;\n  [key: string]: unknown;\n}\n\n// Module-level singleton so all loggers share the same ALS store.\nconst _storage = new AsyncLocalStorage<LogContext>();\n\nexport const LogixiaContext = {\n  /**\n   * Run `callback` inside an async context that carries `store` fields.\n   * All loggers queried within `callback` (and its async descendants) will\n   * automatically see these fields.\n   *\n   * @example\n   * ```ts\n   * LogixiaContext.run({ requestId: 'abc', userId: '42' }, async () => {\n   *   await processOrder();   // sees requestId + userId in every log\n   * });\n   * ```\n   */\n  run<T>(store: LogContext, callback: () => T): T {\n    const parent = _storage.getStore() ?? {};\n    const scoped = (): T => _storage.run({ ...parent, ...store }, callback);\n    const traceId = store.traceId;\n    if (typeof traceId !== 'string' || traceId === '') return scoped();\n    // An explicit traceId also becomes the TraceContext ID, so getCurrentTraceId(),\n    // the logger, outbound propagation and the OTel bridge all see the same value.\n    const trace = TraceContext.instance;\n    return trace.storage.run({ ...trace.storage.getStore(), [trace.contextKey]: traceId }, scoped);\n  },\n\n  /**\n   * Return the context fields active in the current async scope.\n   * Returns `undefined` when called outside any `LogixiaContext.run()`.\n   */\n  get(): LogContext | undefined {\n    return _storage.getStore();\n  },\n\n  /**\n   * Merge `fields` into the **existing** context for the current scope.\n   * If called outside a `run()` context this is a no-op (logs a dev warning).\n   */\n  set(fields: Partial<LogContext>): void {\n    const store = _storage.getStore();\n    if (!store) {\n      // Silently ignore — avoids crashing in code that may call setContext\n      // before a request context is established (e.g. background jobs).\n      return;\n    }\n    for (const key of Object.keys(fields)) {\n      if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;\n      store[key] = fields[key];\n    }\n  },\n\n  /**\n   * Retrieve the underlying `AsyncLocalStorage` instance.\n   * Useful for advanced use-cases like custom middleware.\n   */\n  getStorage(): AsyncLocalStorage<LogContext> {\n    return _storage;\n  },\n};\n\nexport type { ContextRequestLike };\n\ninterface ContextHelperOptions<Req extends ContextRequestLike> {\n  /**\n   * Extract additional fields from the request. A `traceId` returned here is ignored:\n   * the resolved request trace ID always wins.\n   */\n  enrich?: (request: Req & Record<string, unknown>) => Partial<LogContext>;\n  /**\n   * Header name, or list of names tried in order, to read the trace ID from.\n   * Default: `DEFAULT_TRACE_HEADERS` (traceparent is parsed to its 32-hex trace id).\n   */\n  traceIdHeader?: TraceHeaderOption;\n  /**\n   * Echo the resolved trace ID on the response under this header name.\n   * Default: `false` (no response header is set).\n   */\n  responseHeader?: string | false;\n}\n\nfunction buildScope<Req extends ContextRequestLike>(\n  request: Req,\n  options: ContextHelperOptions<Req>,\n  headers: readonly string[]\n): LogContext {\n  const extra = options.enrich ? options.enrich(request as Req & Record<string, unknown>) : {};\n  return { ...extra, traceId: resolveRequestTraceId(request, headers) };\n}\n\n/**\n * Create an Express/Connect-compatible middleware that wraps each request in\n * a `LogixiaContext.run()` scope populated with common request fields.\n *\n * Trace ID: the first present header of `traceIdHeader` (default\n * `DEFAULT_TRACE_HEADERS`, `traceparent` parsed), else `request.id`, else a\n * generated UUID. It is available via `getCurrentTraceId()` and is the logger's\n * top-level `traceId` inside the request. No response header is set unless\n * `responseHeader` is given.\n *\n * @example\n * ```ts\n * import { createExpressContextMiddleware } from 'logixia';\n * app.use(createExpressContextMiddleware({ responseHeader: 'x-trace-id' }));\n * ```\n */\nexport function createExpressContextMiddleware<Req extends ContextRequestLike = ContextRequestLike>(\n  options: ContextHelperOptions<Req> = {}\n) {\n  const headers = resolveTraceHeaders(options.traceIdHeader);\n\n  return function logixiaContextMiddleware(\n    req: Req,\n    res: { setHeader?: (name: string, value: string) => unknown },\n    next: () => void\n  ): void {\n    const scope = buildScope(req, options, headers);\n    if (options.responseHeader) res.setHeader?.(options.responseHeader, scope.traceId as string);\n    LogixiaContext.run(scope, next);\n  };\n}\n\n/**\n * Create a Fastify lifecycle hook that wraps each request in a context scope.\n *\n * Register with `fastify.addHook('onRequest', createFastifyContextHook())`.\n * Resolves the trace ID exactly like {@link createExpressContextMiddleware} and\n * shares it with `createFastifyPlugin()` from `logixia/middleware`. Fastify's\n * default counter `request.id` (`req-1`, ...) is never used as a trace ID.\n */\nexport function createFastifyContextHook<Req extends ContextRequestLike = ContextRequestLike>(\n  options: ContextHelperOptions<Req> = {}\n) {\n  const headers = resolveTraceHeaders(options.traceIdHeader);\n\n  return function logixiaFastifyHook(\n    request: Req,\n    reply: { header?: (name: string, value: string) => unknown },\n    done: () => void\n  ): void {\n    const scope = buildScope(request, options, headers);\n    if (options.responseHeader) reply.header?.(options.responseHeader, scope.traceId as string);\n    LogixiaContext.run(scope, done);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,MAAM,WAAW,IAAI,kBAA8B;AAEnD,MAAa,iBAAiB;;;;;;;;;;;;;CAa5B,IAAO,OAAmB,UAAsB;EAC9C,MAAM,SAAS,SAAS,SAAS,KAAK,CAAC;EACvC,MAAM,eAAkB,SAAS,IAAI;GAAE,GAAG;GAAQ,GAAG;EAAM,GAAG,QAAQ;EACtE,MAAM,UAAU,MAAM;EACtB,IAAI,OAAO,YAAY,YAAY,YAAY,IAAI,OAAO,OAAO;EAGjE,MAAM,QAAQ,aAAa;EAC3B,OAAO,MAAM,QAAQ,IAAI;GAAE,GAAG,MAAM,QAAQ,SAAS;IAAI,MAAM,aAAa;EAAQ,GAAG,MAAM;CAC/F;;;;;CAMA,MAA8B;EAC5B,OAAO,SAAS,SAAS;CAC3B;;;;;CAMA,IAAI,QAAmC;EACrC,MAAM,QAAQ,SAAS,SAAS;EAChC,IAAI,CAAC,OAGH;EAEF,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAAG;GACrC,IAAI,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,aAAa;GACzE,MAAM,OAAO,OAAO;EACtB;CACF;;;;;CAMA,aAA4C;EAC1C,OAAO;CACT;AACF;AAsBA,SAAS,WACP,SACA,SACA,SACY;CAEZ,OAAO;EAAE,GADK,QAAQ,SAAS,QAAQ,OAAO,OAAwC,IAAI,CAAC;EACxE,SAAS,sBAAsB,SAAS,OAAO;CAAE;AACtE;;;;;;;;;;;;;;;;;AAkBA,SAAgB,+BACd,UAAqC,CAAC,GACtC;CACA,MAAM,UAAU,oBAAoB,QAAQ,aAAa;CAEzD,OAAO,SAAS,yBACd,KACA,KACA,MACM;;EACN,MAAM,QAAQ,WAAW,KAAK,SAAS,OAAO;EAC9C,IAAI,QAAQ,gBAAgB,CAAA,iBAAA,IAAI,eAAA,QAAA,mBAAA,KAAA,KAAA,eAAA,KAAA,KAAY,QAAQ,gBAAgB,MAAM,OAAiB;EAC3F,eAAe,IAAI,OAAO,IAAI;CAChC;AACF;;;;;;;;;AAUA,SAAgB,yBACd,UAAqC,CAAC,GACtC;CACA,MAAM,UAAU,oBAAoB,QAAQ,aAAa;CAEzD,OAAO,SAAS,mBACd,SACA,OACA,MACM;;EACN,MAAM,QAAQ,WAAW,SAAS,SAAS,OAAO;EAClD,IAAI,QAAQ,gBAAgB,CAAA,gBAAA,MAAM,YAAA,QAAA,kBAAA,KAAA,KAAA,cAAA,KAAA,OAAS,QAAQ,gBAAgB,MAAM,OAAiB;EAC1F,eAAe,IAAI,OAAO,IAAI;CAChC;AACF"}

package/dist/async-context-DTQgi8f7.js

@@ -0,0 +1,150 @@
+const require_request_trace = require("./request-trace-wTJdKp6-.js");
+// src/context/async-context.ts
+/**
+* LogixiaContext — Zero-boilerplate AsyncLocalStorage context propagation.
+*
+* Lets every `logger.info()` call inside a context automatically pick up stored
+* fields (requestId, userId, tenantId, …) without passing them through every function.
+*
+* Works across `Promise.all`, `setTimeout`, and event emitters — anything that
+* inherits the async execution context.
+*
+* @example
+* ```ts
+* import { LogixiaContext } from 'logixia';
+*
+* // Wrap a request handler:
+* app.use((req, res, next) => {
+*   LogixiaContext.run({ requestId: req.id, userId: req.user?.id }, next);
+* });
+*
+* // Anywhere deeper in the call tree:
+* async function processOrder(orderId: string) {
+*   const ctx = LogixiaContext.get();  // { requestId, userId, orderId }
+*   logger.info('Processing order', { orderId, ...ctx });
+* }
+* ```
+*/
+const _storage = new (require("node:async_hooks")).AsyncLocalStorage();
+const LogixiaContext = {
+	/**
+	* Run `callback` inside an async context that carries `store` fields.
+	* All loggers queried within `callback` (and its async descendants) will
+	* automatically see these fields.
+	*
+	* @example
+	* ```ts
+	* LogixiaContext.run({ requestId: 'abc', userId: '42' }, async () => {
+	*   await processOrder();   // sees requestId + userId in every log
+	* });
+	* ```
+	*/
+	run(store, callback) {
+		const parent = _storage.getStore() ?? {};
+		const scoped = () => _storage.run({
+			...parent,
+			...store
+		}, callback);
+		const traceId = store.traceId;
+		if (typeof traceId !== "string" || traceId === "") return scoped();
+		const trace = require_request_trace.TraceContext.instance;
+		return trace.storage.run({
+			...trace.storage.getStore(),
+			[trace.contextKey]: traceId
+		}, scoped);
+	},
+	/**
+	* Return the context fields active in the current async scope.
+	* Returns `undefined` when called outside any `LogixiaContext.run()`.
+	*/
+	get() {
+		return _storage.getStore();
+	},
+	/**
+	* Merge `fields` into the **existing** context for the current scope.
+	* If called outside a `run()` context this is a no-op (logs a dev warning).
+	*/
+	set(fields) {
+		const store = _storage.getStore();
+		if (!store) return;
+		for (const key of Object.keys(fields)) {
+			if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+			store[key] = fields[key];
+		}
+	},
+	/**
+	* Retrieve the underlying `AsyncLocalStorage` instance.
+	* Useful for advanced use-cases like custom middleware.
+	*/
+	getStorage() {
+		return _storage;
+	}
+};
+function buildScope(request, options, headers) {
+	return {
+		...options.enrich ? options.enrich(request) : {},
+		traceId: require_request_trace.resolveRequestTraceId(request, headers)
+	};
+}
+/**
+* Create an Express/Connect-compatible middleware that wraps each request in
+* a `LogixiaContext.run()` scope populated with common request fields.
+*
+* Trace ID: the first present header of `traceIdHeader` (default
+* `DEFAULT_TRACE_HEADERS`, `traceparent` parsed), else `request.id`, else a
+* generated UUID. It is available via `getCurrentTraceId()` and is the logger's
+* top-level `traceId` inside the request. No response header is set unless
+* `responseHeader` is given.
+*
+* @example
+* ```ts
+* import { createExpressContextMiddleware } from 'logixia';
+* app.use(createExpressContextMiddleware({ responseHeader: 'x-trace-id' }));
+* ```
+*/
+function createExpressContextMiddleware(options = {}) {
+	const headers = require_request_trace.resolveTraceHeaders(options.traceIdHeader);
+	return function logixiaContextMiddleware(req, res, next) {
+		var _res$setHeader;
+		const scope = buildScope(req, options, headers);
+		if (options.responseHeader) (_res$setHeader = res.setHeader) === null || _res$setHeader === void 0 || _res$setHeader.call(res, options.responseHeader, scope.traceId);
+		LogixiaContext.run(scope, next);
+	};
+}
+/**
+* Create a Fastify lifecycle hook that wraps each request in a context scope.
+*
+* Register with `fastify.addHook('onRequest', createFastifyContextHook())`.
+* Resolves the trace ID exactly like {@link createExpressContextMiddleware} and
+* shares it with `createFastifyPlugin()` from `logixia/middleware`. Fastify's
+* default counter `request.id` (`req-1`, ...) is never used as a trace ID.
+*/
+function createFastifyContextHook(options = {}) {
+	const headers = require_request_trace.resolveTraceHeaders(options.traceIdHeader);
+	return function logixiaFastifyHook(request, reply, done) {
+		var _reply$header;
+		const scope = buildScope(request, options, headers);
+		if (options.responseHeader) (_reply$header = reply.header) === null || _reply$header === void 0 || _reply$header.call(reply, options.responseHeader, scope.traceId);
+		LogixiaContext.run(scope, done);
+	};
+}
+Object.defineProperty(exports, "LogixiaContext", {
+	enumerable: true,
+	get: function() {
+		return LogixiaContext;
+	}
+});
+Object.defineProperty(exports, "createExpressContextMiddleware", {
+	enumerable: true,
+	get: function() {
+		return createExpressContextMiddleware;
+	}
+});
+Object.defineProperty(exports, "createFastifyContextHook", {
+	enumerable: true,
+	get: function() {
+		return createFastifyContextHook;
+	}
+});
+
+//# sourceMappingURL=async-context-DTQgi8f7.js.map

package/dist/async-context-DTQgi8f7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context-DTQgi8f7.js","names":["AsyncLocalStorage","TraceContext","resolveRequestTraceId","resolveTraceHeaders"],"sources":["../src/context/async-context.ts"],"sourcesContent":["/**\n * LogixiaContext — Zero-boilerplate AsyncLocalStorage context propagation.\n *\n * Lets every `logger.info()` call inside a context automatically pick up stored\n * fields (requestId, userId, tenantId, …) without passing them through every function.\n *\n * Works across `Promise.all`, `setTimeout`, and event emitters — anything that\n * inherits the async execution context.\n *\n * @example\n * ```ts\n * import { LogixiaContext } from 'logixia';\n *\n * // Wrap a request handler:\n * app.use((req, res, next) => {\n *   LogixiaContext.run({ requestId: req.id, userId: req.user?.id }, next);\n * });\n *\n * // Anywhere deeper in the call tree:\n * async function processOrder(orderId: string) {\n *   const ctx = LogixiaContext.get();  // { requestId, userId, orderId }\n *   logger.info('Processing order', { orderId, ...ctx });\n * }\n * ```\n */\n\nimport { AsyncLocalStorage } from 'node:async_hooks';\n\nimport {\n  type ContextRequestLike,\n  resolveRequestTraceId,\n  resolveTraceHeaders,\n  type TraceHeaderOption,\n} from '../utils/request-trace';\nimport { TraceContext } from '../utils/trace.utils';\n\nexport interface LogContext {\n  traceId?: string;\n  spanId?: string;\n  userId?: string;\n  tenantId?: string;\n  sessionId?: string;\n  [key: string]: unknown;\n}\n\n// Module-level singleton so all loggers share the same ALS store.\nconst _storage = new AsyncLocalStorage<LogContext>();\n\nexport const LogixiaContext = {\n  /**\n   * Run `callback` inside an async context that carries `store` fields.\n   * All loggers queried within `callback` (and its async descendants) will\n   * automatically see these fields.\n   *\n   * @example\n   * ```ts\n   * LogixiaContext.run({ requestId: 'abc', userId: '42' }, async () => {\n   *   await processOrder();   // sees requestId + userId in every log\n   * });\n   * ```\n   */\n  run<T>(store: LogContext, callback: () => T): T {\n    const parent = _storage.getStore() ?? {};\n    const scoped = (): T => _storage.run({ ...parent, ...store }, callback);\n    const traceId = store.traceId;\n    if (typeof traceId !== 'string' || traceId === '') return scoped();\n    // An explicit traceId also becomes the TraceContext ID, so getCurrentTraceId(),\n    // the logger, outbound propagation and the OTel bridge all see the same value.\n    const trace = TraceContext.instance;\n    return trace.storage.run({ ...trace.storage.getStore(), [trace.contextKey]: traceId }, scoped);\n  },\n\n  /**\n   * Return the context fields active in the current async scope.\n   * Returns `undefined` when called outside any `LogixiaContext.run()`.\n   */\n  get(): LogContext | undefined {\n    return _storage.getStore();\n  },\n\n  /**\n   * Merge `fields` into the **existing** context for the current scope.\n   * If called outside a `run()` context this is a no-op (logs a dev warning).\n   */\n  set(fields: Partial<LogContext>): void {\n    const store = _storage.getStore();\n    if (!store) {\n      // Silently ignore — avoids crashing in code that may call setContext\n      // before a request context is established (e.g. background jobs).\n      return;\n    }\n    for (const key of Object.keys(fields)) {\n      if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;\n      store[key] = fields[key];\n    }\n  },\n\n  /**\n   * Retrieve the underlying `AsyncLocalStorage` instance.\n   * Useful for advanced use-cases like custom middleware.\n   */\n  getStorage(): AsyncLocalStorage<LogContext> {\n    return _storage;\n  },\n};\n\nexport type { ContextRequestLike };\n\ninterface ContextHelperOptions<Req extends ContextRequestLike> {\n  /**\n   * Extract additional fields from the request. A `traceId` returned here is ignored:\n   * the resolved request trace ID always wins.\n   */\n  enrich?: (request: Req & Record<string, unknown>) => Partial<LogContext>;\n  /**\n   * Header name, or list of names tried in order, to read the trace ID from.\n   * Default: `DEFAULT_TRACE_HEADERS` (traceparent is parsed to its 32-hex trace id).\n   */\n  traceIdHeader?: TraceHeaderOption;\n  /**\n   * Echo the resolved trace ID on the response under this header name.\n   * Default: `false` (no response header is set).\n   */\n  responseHeader?: string | false;\n}\n\nfunction buildScope<Req extends ContextRequestLike>(\n  request: Req,\n  options: ContextHelperOptions<Req>,\n  headers: readonly string[]\n): LogContext {\n  const extra = options.enrich ? options.enrich(request as Req & Record<string, unknown>) : {};\n  return { ...extra, traceId: resolveRequestTraceId(request, headers) };\n}\n\n/**\n * Create an Express/Connect-compatible middleware that wraps each request in\n * a `LogixiaContext.run()` scope populated with common request fields.\n *\n * Trace ID: the first present header of `traceIdHeader` (default\n * `DEFAULT_TRACE_HEADERS`, `traceparent` parsed), else `request.id`, else a\n * generated UUID. It is available via `getCurrentTraceId()` and is the logger's\n * top-level `traceId` inside the request. No response header is set unless\n * `responseHeader` is given.\n *\n * @example\n * ```ts\n * import { createExpressContextMiddleware } from 'logixia';\n * app.use(createExpressContextMiddleware({ responseHeader: 'x-trace-id' }));\n * ```\n */\nexport function createExpressContextMiddleware<Req extends ContextRequestLike = ContextRequestLike>(\n  options: ContextHelperOptions<Req> = {}\n) {\n  const headers = resolveTraceHeaders(options.traceIdHeader);\n\n  return function logixiaContextMiddleware(\n    req: Req,\n    res: { setHeader?: (name: string, value: string) => unknown },\n    next: () => void\n  ): void {\n    const scope = buildScope(req, options, headers);\n    if (options.responseHeader) res.setHeader?.(options.responseHeader, scope.traceId as string);\n    LogixiaContext.run(scope, next);\n  };\n}\n\n/**\n * Create a Fastify lifecycle hook that wraps each request in a context scope.\n *\n * Register with `fastify.addHook('onRequest', createFastifyContextHook())`.\n * Resolves the trace ID exactly like {@link createExpressContextMiddleware} and\n * shares it with `createFastifyPlugin()` from `logixia/middleware`. Fastify's\n * default counter `request.id` (`req-1`, ...) is never used as a trace ID.\n */\nexport function createFastifyContextHook<Req extends ContextRequestLike = ContextRequestLike>(\n  options: ContextHelperOptions<Req> = {}\n) {\n  const headers = resolveTraceHeaders(options.traceIdHeader);\n\n  return function logixiaFastifyHook(\n    request: Req,\n    reply: { header?: (name: string, value: string) => unknown },\n    done: () => void\n  ): void {\n    const scope = buildScope(request, options, headers);\n    if (options.responseHeader) reply.header?.(options.responseHeader, scope.traceId as string);\n    LogixiaContext.run(scope, done);\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,MAAM,WAAW,K,0BAAIA,EAAAA,CAAAA,kBAA8B;AAEnD,MAAa,iBAAiB;;;;;;;;;;;;;CAa5B,IAAO,OAAmB,UAAsB;EAC9C,MAAM,SAAS,SAAS,SAAS,KAAK,CAAC;EACvC,MAAM,eAAkB,SAAS,IAAI;GAAE,GAAG;GAAQ,GAAG;EAAM,GAAG,QAAQ;EACtE,MAAM,UAAU,MAAM;EACtB,IAAI,OAAO,YAAY,YAAY,YAAY,IAAI,OAAO,OAAO;EAGjE,MAAM,QAAQC,sBAAAA,aAAa;EAC3B,OAAO,MAAM,QAAQ,IAAI;GAAE,GAAG,MAAM,QAAQ,SAAS;IAAI,MAAM,aAAa;EAAQ,GAAG,MAAM;CAC/F;;;;;CAMA,MAA8B;EAC5B,OAAO,SAAS,SAAS;CAC3B;;;;;CAMA,IAAI,QAAmC;EACrC,MAAM,QAAQ,SAAS,SAAS;EAChC,IAAI,CAAC,OAGH;EAEF,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAAG;GACrC,IAAI,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,aAAa;GACzE,MAAM,OAAO,OAAO;EACtB;CACF;;;;;CAMA,aAA4C;EAC1C,OAAO;CACT;AACF;AAsBA,SAAS,WACP,SACA,SACA,SACY;CAEZ,OAAO;EAAE,GADK,QAAQ,SAAS,QAAQ,OAAO,OAAwC,IAAI,CAAC;EACxE,SAASC,sBAAAA,sBAAsB,SAAS,OAAO;CAAE;AACtE;;;;;;;;;;;;;;;;;AAkBA,SAAgB,+BACd,UAAqC,CAAC,GACtC;CACA,MAAM,UAAUC,sBAAAA,oBAAoB,QAAQ,aAAa;CAEzD,OAAO,SAAS,yBACd,KACA,KACA,MACM;;EACN,MAAM,QAAQ,WAAW,KAAK,SAAS,OAAO;EAC9C,IAAI,QAAQ,gBAAgB,CAAA,iBAAA,IAAI,eAAA,QAAA,mBAAA,KAAA,KAAA,eAAA,KAAA,KAAY,QAAQ,gBAAgB,MAAM,OAAiB;EAC3F,eAAe,IAAI,OAAO,IAAI;CAChC;AACF;;;;;;;;;AAUA,SAAgB,yBACd,UAAqC,CAAC,GACtC;CACA,MAAM,UAAUA,sBAAAA,oBAAoB,QAAQ,aAAa;CAEzD,OAAO,SAAS,mBACd,SACA,OACA,MACM;;EACN,MAAM,QAAQ,WAAW,SAAS,SAAS,OAAO;EAClD,IAAI,QAAQ,gBAAgB,CAAA,gBAAA,MAAM,YAAA,QAAA,kBAAA,KAAA,KAAA,cAAA,KAAA,OAAS,QAAQ,gBAAgB,MAAM,OAAiB;EAC1F,eAAe,IAAI,OAAO,IAAI;CAChC;AACF"}

package/dist/{azure-monitor.transport-CHnjVRF-.mjs → azure-monitor.transport-BPbgjATu.mjs}

@@ -1,8 +1,8 @@
-import { r as internalWarn, t as internalError } from "./internal-log-Cm8SOWSV.mjs";
-import { i as stringifyForLog } from "./safe-stringify-DJ66tW5I.mjs";
-import { a as httpRequest, n as DEFAULT_MAX_BUFFER_SIZE, r as DEFAULT_REQUEST_TIMEOUT_MS, t as BatchBuffer } from "./batch-buffer-PGvSgbmd.mjs";
-
-//#region src/transports/azure-monitor.transport.ts
+import { r as internalWarn, t as internalError } from "./internal-log-uCSd1PMc.mjs";
+import { i as scrubSecrets, n as protectSecrets, o as urlSecrets, r as scrubError } from "./secret-config-BegMLkYl.mjs";
+import { i as stringifyForLog } from "./safe-stringify-BMRl3EX3.mjs";
+import { a as httpRequest, t as BatchBuffer } from "./batch-buffer-0fgLmIPn.mjs";
+// src/transports/azure-monitor.transport.ts
 /**
 * Azure AD tenant IDs are either a GUID or a verified domain (e.g. `contoso.onmicrosoft.com`).
 * This pattern is deliberately permissive on structure but strict on character
@@ -32,6 +32,7 @@ var AzureMonitorTransport = class {
 		this.flushTimer = null;
 		this.accessToken = null;
 		this.tokenExpiry = 0;
+		protectSecrets(this, ["clientSecret", "accessToken"]);
 		this.endpoint = config.endpoint.replace(/\/$/, "");
 		this.ruleId = config.ruleId;
 		this.streamName = config.streamName;
@@ -41,12 +42,13 @@ var AzureMonitorTransport = class {
 		this.batchSize = config.batchSize ?? 200;
 		this.flushInterval = config.flushIntervalMs ?? 5e3;
 		this.level = config.level;
-		this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+		this.requestTimeoutMs = config.requestTimeoutMs ?? 1e4;
 		this.buffer = new BatchBuffer({
 			name: "AzureMonitorTransport",
 			batchSize: this.batchSize,
-			maxBufferSize: config.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE,
-			send: (entries) => this.sendEntries(entries)
+			maxBufferSize: config.maxBufferSize ?? 1e4,
+			send: (entries) => this.sendEntries(entries),
+			secrets: () => this.secretValues()
 		});
 		this.flushTimer = setInterval(() => {
 			this.flush().catch(() => {});
@@ -83,6 +85,14 @@ var AzureMonitorTransport = class {
 			Properties: stringifyForLog(entry.data ?? {})
 		};
 	}
+	secretValues(token) {
+		return [
+			this.clientSecret,
+			this.accessToken ?? void 0,
+			token,
+			...urlSecrets(this.endpoint)
+		];
+	}
 	async getAccessToken() {
 		if (this.accessToken && Date.now() < this.tokenExpiry) return this.accessToken;
 		if (!this.tenantId || !this.clientId || !this.clientSecret) {
@@ -107,7 +117,8 @@ var AzureMonitorTransport = class {
 				headers: { "Content-Type": "application/x-www-form-urlencoded" },
 				body,
 				timeoutMs: this.requestTimeoutMs,
-				label: "Azure token request"
+				label: "Azure token request",
+				secrets: () => this.secretValues()
 			});
 			const parsed = JSON.parse(res.body);
 			if (!parsed.access_token) return null;
@@ -122,12 +133,13 @@ var AzureMonitorTransport = class {
 	async sendEntries(entries) {
 		const token = await this.getAccessToken();
 		if (!token) throw new Error("AzureMonitorTransport: no access token available");
-		const body = stringifyForLog(entries.map((e) => this.toAzureRecord(e)));
+		const records = entries.map((e) => this.toAzureRecord(e));
+		const body = stringifyForLog(records);
 		let reqUrl;
 		try {
 			reqUrl = new URL(`dataCollectionRules/${encodeURIComponent(this.ruleId)}/streams/${encodeURIComponent(this.streamName)}?api-version=2023-01-01`, this.endpoint.endsWith("/") ? this.endpoint : `${this.endpoint}/`);
 		} catch (error) {
-			internalError(`AzureMonitorTransport: invalid endpoint "${this.endpoint}"`, error);
+			internalError(`AzureMonitorTransport: invalid endpoint "${scrubSecrets(this.endpoint, urlSecrets(this.endpoint))}"`, scrubError(error, urlSecrets(this.endpoint)));
 			return;
 		}
 		if (reqUrl.protocol !== "https:") {
@@ -142,11 +154,11 @@ var AzureMonitorTransport = class {
 			},
 			body,
 			timeoutMs: this.requestTimeoutMs,
-			label: "Azure Monitor API"
+			label: "Azure Monitor API",
+			secrets: () => this.secretValues(token)
 		});
 	}
 };
-
-//#endregion
 export { AzureMonitorTransport as t };
-//# sourceMappingURL=azure-monitor.transport-CHnjVRF-.mjs.map
+
+//# sourceMappingURL=azure-monitor.transport-BPbgjATu.mjs.map

package/dist/azure-monitor.transport-BPbgjATu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"azure-monitor.transport-BPbgjATu.mjs","names":[],"sources":["../src/transports/azure-monitor.transport.ts"],"sourcesContent":["/**\n * logixia — Azure Monitor / Application Insights transport\n *\n * Sends log entries to Azure Monitor via the Data Collection Rules (DCR) API\n * using the Logs Ingestion API (the modern replacement for the legacy HTTP\n * Data Collector API).\n *\n * Maps logixia levels to Application Insights severity levels:\n *   verbose → 0, debug → 1, info → 1, warn → 2, error → 3, critical → 4\n *\n * @example\n * ```ts\n * import { AzureMonitorTransport } from 'logixia';\n *\n * const logger = createLogger({\n *   transports: {\n *     azure: new AzureMonitorTransport({\n *       // Logs Ingestion API endpoint (from your DCR)\n *       endpoint: 'https://<dce>.ingest.monitor.azure.com',\n *       ruleId: 'dcr-xxxxxxxxxxxxxxxx',\n *       streamName: 'Custom-LogixiaLogs',\n *       // Client credentials (or managed identity via no-credential mode)\n *       tenantId: process.env.AZURE_TENANT_ID,\n *       clientId: process.env.AZURE_CLIENT_ID,\n *       clientSecret: process.env.AZURE_CLIENT_SECRET,\n *     }),\n *   },\n * });\n * ```\n */\n\nimport type { IAsyncTransport, TransportLogEntry } from '../types/transport.types';\nimport { internalError, internalWarn } from '../utils/internal-log';\nimport { stringifyForLog } from '../utils/safe-stringify';\nimport {\n  BatchBuffer,\n  DEFAULT_MAX_BUFFER_SIZE,\n  DEFAULT_REQUEST_TIMEOUT_MS,\n  httpRequest,\n} from './batch-buffer';\nimport { protectSecrets, scrubError, scrubSecrets, urlSecrets } from './secret-config';\n\n/**\n * Azure AD tenant IDs are either a GUID or a verified domain (e.g. `contoso.onmicrosoft.com`).\n * This pattern is deliberately permissive on structure but strict on character\n * set — it rejects the breakout characters (`/`, `@`, `:`, `?`, `#`, whitespace)\n * that would let a hostile config smuggle a different host, path, or query into\n * the OAuth token URL.\n */\nconst AZURE_TENANT_RE = /^[a-z0-9][a-z0-9.-]{1,253}$/i;\n\nexport interface AzureMonitorTransportConfig {\n  /** DCE (Data Collection Endpoint) URL, e.g. `https://<name>.ingest.monitor.azure.com`. */\n  endpoint: string;\n  /** Data Collection Rule immutable ID (from Azure portal). */\n  ruleId: string;\n  /** Stream name defined in the DCR, e.g. `'Custom-LogixiaLogs_CL'`. */\n  streamName: string;\n  /** Azure AD tenant ID for OAuth2 client-credentials flow. */\n  tenantId?: string;\n  /** Azure AD app (service principal) client ID. */\n  clientId?: string;\n  /** Azure AD app client secret. */\n  clientSecret?: string;\n  /** Number of entries to batch. @default 200 */\n  batchSize?: number;\n  /** Flush interval in ms. @default 5000 */\n  flushIntervalMs?: number;\n  /** Abort a request that has not finished after this many ms. @default 10000 */\n  requestTimeoutMs?: number;\n  /** Max buffered entries; the oldest are dropped past this. @default 10000 */\n  maxBufferSize?: number;\n  level?: string;\n}\n\nconst SEVERITY_MAP: Record<string, number> = {\n  verbose: 0,\n  trace: 0,\n  debug: 1,\n  info: 1,\n  log: 1,\n  warn: 2,\n  warning: 2,\n  error: 3,\n  critical: 4,\n  fatal: 4,\n};\n\n/**\n * Azure Monitor Logs Ingestion transport.\n */\nexport class AzureMonitorTransport implements IAsyncTransport {\n  public readonly name = 'azure-monitor';\n  public readonly batchSize: number;\n  public readonly flushInterval: number;\n  public readonly level: string | undefined;\n\n  private readonly buffer: BatchBuffer<TransportLogEntry>;\n  private readonly requestTimeoutMs: number;\n  private flushTimer: NodeJS.Timeout | null = null;\n  private accessToken: string | null = null;\n  private tokenExpiry = 0;\n\n  private readonly endpoint: string;\n  private readonly ruleId: string;\n  private readonly streamName: string;\n  private readonly tenantId: string | undefined;\n  private readonly clientId: string | undefined;\n  private readonly clientSecret: string | undefined;\n\n  constructor(config: AzureMonitorTransportConfig) {\n    protectSecrets(this, ['clientSecret', 'accessToken']);\n    this.endpoint = config.endpoint.replace(/\\/$/, '');\n    this.ruleId = config.ruleId;\n    this.streamName = config.streamName;\n    this.tenantId = config.tenantId ?? process.env['AZURE_TENANT_ID'];\n    this.clientId = config.clientId ?? process.env['AZURE_CLIENT_ID'];\n    this.clientSecret = config.clientSecret ?? process.env['AZURE_CLIENT_SECRET'];\n    this.batchSize = config.batchSize ?? 200;\n    this.flushInterval = config.flushIntervalMs ?? 5000;\n    this.level = config.level;\n    this.requestTimeoutMs = config.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;\n    this.buffer = new BatchBuffer<TransportLogEntry>({\n      name: 'AzureMonitorTransport',\n      batchSize: this.batchSize,\n      maxBufferSize: config.maxBufferSize ?? DEFAULT_MAX_BUFFER_SIZE,\n      send: (entries) => this.sendEntries(entries),\n      secrets: () => this.secretValues(),\n    });\n\n    this.flushTimer = setInterval(() => {\n      this.flush().catch(() => {});\n    }, this.flushInterval);\n    if (this.flushTimer.unref) this.flushTimer.unref();\n  }\n\n  write(entry: TransportLogEntry): void {\n    this.buffer.push(entry);\n    this.buffer.flushIfFull();\n  }\n\n  flush(): Promise<void> {\n    return this.buffer.flush();\n  }\n\n  /**\n   * Flush remaining entries and stop the interval timer on shutdown. Without\n   * this the manager's close() skipped the transport (close was undefined) and\n   * buffered entries were lost on deploy. Waits for any in-flight send first.\n   */\n  async close(): Promise<void> {\n    if (this.flushTimer) {\n      clearInterval(this.flushTimer);\n      this.flushTimer = null;\n    }\n    await this.buffer.close();\n  }\n\n  private toAzureRecord(entry: TransportLogEntry): Record<string, unknown> {\n    return {\n      TimeGenerated: entry.timestamp ?? new Date().toISOString(),\n      SeverityLevel: SEVERITY_MAP[entry.level.toLowerCase()] ?? 1,\n      Message: entry.message,\n      AppName: entry.appName,\n      Context: entry.context ?? '',\n      TraceId: entry.traceId ?? '',\n      Properties: stringifyForLog(entry.data ?? {}),\n    };\n  }\n\n  private secretValues(token?: string): (string | undefined)[] {\n    return [this.clientSecret, this.accessToken ?? undefined, token, ...urlSecrets(this.endpoint)];\n  }\n\n  private async getAccessToken(): Promise<string | null> {\n    if (this.accessToken && Date.now() < this.tokenExpiry) return this.accessToken;\n\n    if (!this.tenantId || !this.clientId || !this.clientSecret) {\n      internalWarn(\n        'AzureMonitorTransport: missing credentials — set tenantId, clientId, clientSecret'\n      );\n      return null;\n    }\n\n    const body = new URLSearchParams({\n      grant_type: 'client_credentials',\n      client_id: this.clientId,\n      client_secret: this.clientSecret,\n      scope: 'https://monitor.azure.com/.default',\n    }).toString();\n\n    const tenantId = this.tenantId;\n    if (!AZURE_TENANT_RE.test(tenantId)) {\n      internalWarn(\n        `AzureMonitorTransport: refusing to request token — tenantId \"${tenantId}\" is not a valid GUID or domain`\n      );\n      return null;\n    }\n\n    const reqUrl = new URL(\n      `https://login.microsoftonline.com/${encodeURIComponent(tenantId)}/oauth2/v2.0/token`\n    );\n    try {\n      const res = await httpRequest({\n        url: reqUrl,\n        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n        body,\n        timeoutMs: this.requestTimeoutMs,\n        label: 'Azure token request',\n        secrets: () => this.secretValues(),\n      });\n      const parsed = JSON.parse(res.body) as { access_token?: string; expires_in?: number };\n      if (!parsed.access_token) return null;\n      this.accessToken = parsed.access_token;\n      this.tokenExpiry = Date.now() + (parsed.expires_in ?? 3600) * 1000 - 60_000;\n      return this.accessToken;\n    } catch (err) {\n      internalError('AzureMonitorTransport token request failed', err);\n      return null;\n    }\n  }\n\n  private async sendEntries(entries: TransportLogEntry[]): Promise<void> {\n    const token = await this.getAccessToken();\n    if (!token) throw new Error('AzureMonitorTransport: no access token available');\n\n    const records = entries.map((e) => this.toAzureRecord(e));\n    const body = stringifyForLog(records);\n    let reqUrl: URL;\n    try {\n      // Build from the user-configured DCE endpoint; encodeURIComponent-ing the\n      // ruleId/streamName stops a hostile config from smuggling extra path\n      // segments or query params into the request.\n      reqUrl = new URL(\n        `dataCollectionRules/${encodeURIComponent(this.ruleId)}/streams/${encodeURIComponent(this.streamName)}?api-version=2023-01-01`,\n        this.endpoint.endsWith('/') ? this.endpoint : `${this.endpoint}/`\n      );\n    } catch (error) {\n      internalError(\n        `AzureMonitorTransport: invalid endpoint \"${scrubSecrets(this.endpoint, urlSecrets(this.endpoint))}\"`,\n        scrubError(error, urlSecrets(this.endpoint))\n      );\n      return;\n    }\n    if (reqUrl.protocol !== 'https:') {\n      internalError(`AzureMonitorTransport: endpoint must use https (got ${reqUrl.protocol})`);\n      return;\n    }\n\n    await httpRequest({\n      url: reqUrl,\n      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },\n      body,\n      timeoutMs: this.requestTimeoutMs,\n      label: 'Azure Monitor API',\n      secrets: () => this.secretValues(token),\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/{azure-monitor.transport-Cn_3Usvu.d.ts → azure-monitor.transport-C7kYyZUW.d.mts}

@@ -1,7 +1,4 @@
-import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-CGoHpWQR.js";
-
-//#region src/transports/azure-monitor.transport.d.ts
-
+import { p as TransportLogEntry, s as IAsyncTransport } from "./transport.types-BJVL1QQl.mjs";
 interface AzureMonitorTransportConfig {
   /** DCE (Data Collection Endpoint) URL, e.g. `https://<name>.ingest.monitor.azure.com`. */
   endpoint: string;
@@ -54,9 +51,9 @@ declare class AzureMonitorTransport implements IAsyncTransport {
    */
   close(): Promise<void>;
   private toAzureRecord;
+  private secretValues;
   private getAccessToken;
   private sendEntries;
 }
-//#endregion
 export { AzureMonitorTransportConfig as n, AzureMonitorTransport as t };
-//# sourceMappingURL=azure-monitor.transport-Cn_3Usvu.d.ts.map
+//# sourceMappingURL=azure-monitor.transport-C7kYyZUW.d.mts.map

package/dist/azure-monitor.transport-C7kYyZUW.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azure-monitor.transport-C7kYyZUW.d.mts","names":[],"sources":["../src/transports/azure-monitor.transport.ts"],"mappings":";UAmDiB;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;EACA;;;;;cAmBW,iCAAiC;WAC5B;WACA;WACA;WACA;mBAEC;mBACA;UACT;UACA;UACA;mBAES;mBACA;mBACA;mBACA;mBACA;mBACA;EAEL,YAAA,QAAQ;EA0BpB,MAAM,OAAO;EAKb,SAAS;;;;;;EASH,SAAS;UAQP;UAYA;UAIM;UAgDA"}