@deepseek-ai/dsh-otel 0.2.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,37 @@
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/telemetry/otel/README.md
+/:
+  en: 49f35d8bc0fe3689
+  zh: ef2fd903cca7d129
+/deepseek-ai-dsh-otel:
+  en: 925bc4650e9895d6
+  zh: 02f8917c4048f6e2
+/deepseek-ai-dsh-otel/summary:
+  en: e32c122f34c04593
+  zh: bea48183ab438454
+/deepseek-ai-dsh-otel/table-of-contents:
+  en: 23386452a66b2fbd
+  zh: 55b2121ae6059425
+/deepseek-ai-dsh-otel/use-this-package:
+  en: f141a9d909c555d8
+  zh: e4f5b690ccb1337c
+/deepseek-ai-dsh-otel/understand-the-implementation:
+  en: 0976ab2c661529bb
+  zh: 9653db33fc70195d
+/deepseek-ai-dsh-otel/further-exploration:
+  en: ee17b991de098cc0
+  zh: f90257e411921f2b
+/deepseek-ai-dsh-otel/model-experience:
+  en: 5b364b9451ced69f
+  zh: 025feb91ef96bdb8
+/deepseek-ai-dsh-otel/model-experience/kv-cache-effect:
+  en: 8be9251f0d5256ed
+  zh: d46143a02855c8bc
+/deepseek-ai-dsh-otel/known-limitations-and-deferred-work:
+  en: 5c3e29312d45ee52
+  zh: b148e3a6decc0f7d
+/deepseek-ai-dsh-otel/known-limitations-and-deferred-work/dev-note:
+  en: 0a1253c6f7b5e8b9
+  zh: 9f56528562c7c914

package/README.md

@@ -0,0 +1,70 @@
+---
+description: "Create independent OTLP reporting channels through the shared Cordis OTel service."
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-otel
+
+English | [中文](README.zh.md)
+
+## Summary
+
+Mount one `otel` service to create ordinary-event and Session-log reporting channels. Each channel has its own exporter, resource, instrumentation scope, and queue. Mounting alone creates no transport or identity and sends nothing. Business consumers own authorization, redaction, field selection, and their channel's disposal.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+<a id="use-this-package"></a>
+## Use this package
+
+The base bundle mounts `@deepseek-ai/dsh-otel`. Independent compositions must mount it before consumers that inject `otel`. Call `ctx.otel.createEventReporter(options)` for ordinary analytics or `ctx.otel.createSessionLogReporter(options)` for complete Session events. Options explicitly supply endpoint, scope, resource attributes, queue settings, and a diagnostic callback; the service has no deployment defaults or automatic collection policy of its own.
+
+The returned channel belongs to the consumer. Ordinary-event `shutdown(signal)` cancels requests and retry waits when the supplied signal aborts, and resolves after transport cleanup. Register shutdown with the consumer's Cordis fiber and bound the complete drain with its configured deadline. Injection makes service replacement unload dependent consumers. Do not retain a channel after its consumer unloads. The product and Session adapters implement this ownership for UI and feedback callers.
+
+Ordinary channels use SDK count-based batching. Session channels preserve one complete event per record with `eventName: "session-log"`, `sessionId`, and a JSON string `content`, and enforce at most 4,000,000 uncompressed request bytes. Their byte limits, single-record rejection, serial transport settlement, and shutdown behavior are specified by the [Session adapter](../../session/session-telemetry-otel/README.md). A Session channel never shares a request or queue with ordinary events.
+
+Headers are explicit. The service does not add a channel header or inherit ambient authorization headers or TLS identity. Agent factories configure their returned agents, including keepAlive. Ordinary-event channels destroy their agent on shutdown; factories must provide a dedicated agent for each channel. Scope names and versions are supplied by each consumer, so transport sharing does not change event attribution.
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+`src/index.ts` registers the service; `event-log.ts` owns ordinary SDK batching; `session-log.ts` owns byte/count scheduling; `transport.ts` supplies the Session SDK JSON HTTP delegate; `event-transport.ts` uses Got for cancellable ordinary-event HTTP requests and retry waits with SDK serialization and export accounting. No global OTel provider is installed. The Session processor measures each record once, groups conservative sizes, and waits for the SDK concurrency queue to clear after every callback before sending another request.
+
+No runtime invariant companion is published: channel creation registers no independent domain state, and collector delivery cannot be inferred from local queues. Composition tests exercise independent channels and service removal; adapter tests cover dependent-fiber cleanup and feedback authorization.
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+- [OTel subsystem](../../../docs/subsystems/otel.md) — service ownership and API.
+- [Product adapter](../../host/product-telemetry-otel/README.md) — explicit analytics policy and configuration.
+- [Session adapter](../../session/session-telemetry-otel/README.md) — feedback authorization and configured upload limits.
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as the service delivers caller-selected records without changing model context.
+
+#### KV Cache effect
+
+None; reporting does not change model requests.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+Channels provide best-effort, memory-only delivery with the following limits.
+
+- The caller owns consent, redaction, resource identity, renderer-to-host RPC, and the outer shutdown deadline.
+- Queue overflow, oversized Session events, transport failure, and process exit can lose records. There is no durable outbox or warehouse acknowledgement.
+- Ordinary-event channels batch by count; their consumers must select event and batch sizes suitable for the collector.
+
+<a id="dev-note"></a>
+### Dev Note
+
+None.

package/README.zh.md

@@ -0,0 +1,70 @@
+---
+description: "通过共享 Cordis OTel 服务创建独立的 OTLP 上报通道。"
+kind: "package-reference"
+---
+
+# @deepseek-ai/dsh-otel
+
+[English](README.md) | 中文
+
+## 概述
+
+挂载一个 `otel` 服务即可创建普通事件和 Session 日志上报通道。每个通道拥有独立的 exporter、resource、instrumentation scope 和队列。仅挂载不会创建传输、身份或发送数据。业务调用方负责授权、脱敏、字段选择及通道销毁。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与后续工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+<a id="use-this-package"></a>
+## 使用本包
+
+base bundle 挂载 `@deepseek-ai/dsh-otel`。独立组合必须在注入 `otel` 的调用方之前挂载它。普通埋点调用 `ctx.otel.createEventReporter(options)`，完整 Session 事件调用 `ctx.otel.createSessionLogReporter(options)`。选项显式提供 endpoint、scope、resource attributes、队列设置和诊断回调；服务本身没有部署默认值或自动采集策略。
+
+返回的通道由调用方持有。普通事件 `shutdown(signal)` 在传入信号中止时取消请求和重试等待，并在传输清理完成后返回。将关闭注册到调用方的 Cordis fiber，并用配置的期限约束完整清空过程。注入机制使服务替换时卸载依赖方。调用方卸载后不得继续保留通道。产品和 Session 适配器为 UI 和反馈调用方实现这些职责。
+
+普通通道使用 SDK 按条数聚合。Session 通道将每条完整事件保留为一个记录，包含 `eventName: "session-log"`、`sessionId` 和 JSON 字符串 `content`，并保证未压缩请求不超过 4,000,000 字节。字节限制、单条拒绝、串行传输结束和关闭行为见 [Session 适配器](../../session/session-telemetry-otel/README.zh.md)。Session 通道不会与普通事件共享请求或队列。
+
+Header 显式提供。服务不会附加 channel header，也不继承环境中的授权 header 或 TLS 身份。Agent factory 配置返回的 agent，包括 keepAlive。普通事件通道在关闭时销毁自己的 agent；factory 必须为每个通道提供独立 agent。每个调用方提供 scope 名称和版本，因此共享传输不会改变事件归属。
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+`src/index.ts` 注册服务；`event-log.ts` 负责普通事件的 SDK 聚合；`session-log.ts` 负责字节和条数调度；`transport.ts` 提供 Session 的 SDK JSON HTTP delegate；`event-transport.ts` 使用 Got 实现可取消的普通事件 HTTP 请求和重试等待，序列化与导出计数仍由 SDK 负责。不安装全局 OTel provider。Session processor 对每条记录只计量一次，按保守大小组包，并在每次回调后等待 SDK 并发队列清理完成才发送下一请求。
+
+不发布运行时不变式伴生入口：通道创建不注册独立领域状态，无法从本地队列推断 collector 是否收到记录。组合测试覆盖独立通道和服务移除；适配器测试覆盖依赖 fiber 清理与反馈授权。
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+- [OTel 子系统](../../../docs/subsystems/otel.zh.md) — 服务职责与 API。
+- [产品适配器](../../host/product-telemetry-otel/README.zh.md) — 显式埋点策略与配置。
+- [Session 适配器](../../session/session-telemetry-otel/README.zh.md) — 反馈授权和上传限制配置。
+
+<a id="model-experience"></a>
+## 模型体验
+
+无，因为服务只投递调用方选择的记录，不改变模型上下文。
+
+#### KV Cache 影响
+
+无；上报不改变模型请求。
+
+## 已知限制与后续工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+通道提供尽力而为的纯内存投递，具有以下限制。
+
+- 调用方负责同意、脱敏、resource 身份、renderer 到 host 的 RPC 及外层关闭期限。
+- 队列溢出、Session 事件超限、传输失败和进程退出可能丢失记录。不提供持久 outbox 或仓库确认。
+- 普通事件通道按条数聚合；调用方必须选择适合 collector 的事件和批次大小。
+
+<a id="dev-note"></a>
+### 开发备注
+
+无。

package/lib/index.js

@@ -0,0 +1,399 @@
+import { Service } from "@deepseek-ai/cordis";
+import { addAbortListener } from "node:events";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { ExportResultCode } from "@opentelemetry/core";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
+import { gzipSync } from "node:zlib";
+import got from "got";
+import { OTLPExporterBase, createOtlpNetworkExportDelegate, getSharedConfigurationDefaults, mergeOtlpSharedConfigurationWithDefaults } from "@opentelemetry/otlp-exporter-base";
+import { JsonLogsSerializer } from "@opentelemetry/otlp-transformer";
+import { createOtlpHttpExportDelegate, getSharedConfigurationFromEnvironment, httpAgentFactoryFromOptions } from "@opentelemetry/otlp-exporter-base/node-http";
+//#region lib/types/transport.js
+/** Explicit OTLP JSON transport for feedback-authorized Session logs. */
+/**
+* Create an SDK JSON exporter without inheriting another collector's headers or TLS identity.
+* @param options - explicit endpoint, headers, agent, and SDK transport settings.
+* @returns the exporter owned by one independent log pipeline.
+*/
+function createLogExporter(options) {
+	return new OTLPExporterBase(createOtlpHttpExportDelegate(logTransportOptions(options), JsonLogsSerializer));
+}
+/**
+* Resolve collector-local headers and agents with shared SDK timeout and compression defaults.
+* @param options - explicit endpoint and SDK HTTP settings.
+* @returns resolved transport settings without ambient credentials.
+*/
+function logTransportOptions(options) {
+	return {
+		...mergeOtlpSharedConfigurationWithDefaults(options, getSharedConfigurationFromEnvironment("LOGS"), getSharedConfigurationDefaults()),
+		url: options.url,
+		headers: async () => ({
+			"Content-Type": "application/json",
+			...typeof options.headers === "function" ? await options.headers() : options.headers
+		}),
+		agentFactory: typeof options.httpAgentOptions === "function" ? options.httpAgentOptions : httpAgentFactoryFromOptions({
+			keepAlive: options.keepAlive ?? true,
+			...options.httpAgentOptions
+		}),
+		...options.userAgent === void 0 ? {} : { userAgent: options.userAgent }
+	};
+}
+//#endregion
+//#region lib/types/event-transport.js
+/**
+* Create a channel-owned exporter whose cancellation releases requests and retry timers.
+* @param options - explicit collector and SDK HTTP settings.
+* @param signal - channel cancellation, shared by current and future batch exports.
+* @returns the SDK exporter; shutdown also destroys its owned HTTP agent.
+*/
+function createEventLogExporter(options, signal) {
+	const config = logTransportOptions(options);
+	let agent;
+	const exporter = new OTLPExporterBase(createOtlpNetworkExportDelegate(config, JsonLogsSerializer, {
+		async send(data, timeoutMillis) {
+			signal.throwIfAborted();
+			agent ??= config.agentFactory(new URL(config.url).protocol);
+			const selectedAgent = await agent;
+			const headers = await config.headers();
+			signal.throwIfAborted();
+			const compressed = config.compression === "gzip";
+			const request = got.post(config.url, {
+				body: compressed ? gzipSync(data) : Buffer.from(data),
+				headers: {
+					...headers,
+					...compressed ? { "content-encoding": "gzip" } : {},
+					...config.userAgent === void 0 ? {} : { "user-agent": config.userAgent }
+				},
+				agent: new URL(config.url).protocol === "https:" ? { https: selectedAgent } : { http: selectedAgent },
+				signal: AbortSignal.any([signal, AbortSignal.timeout(timeoutMillis)]),
+				followRedirect: false,
+				retry: {
+					limit: 5,
+					methods: ["POST"],
+					statusCodes: [
+						429,
+						502,
+						503,
+						504
+					],
+					errorCodes: [],
+					backoffLimit: 5e3
+				},
+				responseType: "buffer"
+			});
+			request.on("downloadProgress", ({ transferred }) => {
+				if (transferred > 4 * 1024 * 1024) request.cancel();
+			});
+			const response = await request;
+			if (response.statusCode >= 300) throw new Error(`OTLP collector returned HTTP ${response.statusCode}`);
+			return {
+				status: "success",
+				data: response.body
+			};
+		},
+		shutdown() {}
+	}));
+	let shutdown;
+	return {
+		export: (records, callback) => {
+			exporter.export(records, callback);
+		},
+		forceFlush: () => exporter.forceFlush(),
+		shutdown() {
+			shutdown ??= (async () => {
+				try {
+					await exporter.shutdown();
+				} finally {
+					(await agent)?.destroy();
+				}
+			})();
+			return shutdown;
+		}
+	};
+}
+//#endregion
+//#region lib/types/event-log.js
+/** One caller-owned ordinary-event queue, independent of every Session-log queue. */
+var EventLogReporter = class {
+	exporter;
+	provider;
+	logger;
+	cancellation = new AbortController();
+	/** @param options - explicit transport, resource, scope, queue, and diagnostic settings. */
+	constructor(options) {
+		const exporter = createEventLogExporter(options.exporter, this.cancellation.signal);
+		this.exporter = exporter;
+		this.provider = new LoggerProvider({
+			resource: resourceFromAttributes(options.resourceAttributes),
+			processors: [new BatchLogRecordProcessor({
+				...options.processor,
+				exporter: {
+					export: (records, callback) => {
+						exporter.export(records, (result) => {
+							if (result.code !== ExportResultCode.SUCCESS) options.onFailure("Product telemetry export failed", result.error);
+							callback(result);
+						});
+					},
+					forceFlush: () => exporter.forceFlush(),
+					shutdown: () => exporter.shutdown()
+				}
+			})]
+		});
+		this.logger = this.provider.getLogger(options.scope.name, options.scope.version);
+	}
+	/**
+	* Enqueue caller-selected analytics fields without acknowledging delivery.
+	* @param record - the ordinary event to report.
+	*/
+	emit(record) {
+		const severityNumber = record.severityNumber ?? SeverityNumber.INFO;
+		this.logger.emit({
+			...record,
+			observedTimestamp: Date.now(),
+			severityNumber,
+			severityText: SeverityNumber[severityNumber]
+		});
+	}
+	/**
+	* Drain the queue and release its transport, cancelling remaining exports when the caller aborts.
+	* @param signal - optional shutdown deadline; abort discards pending exports and cancels retry waits.
+	* @returns completion of SDK shutdown and transport cleanup.
+	*/
+	async shutdown(signal) {
+		const abort = () => {
+			this.cancellation.abort(signal?.reason);
+		};
+		const listener = signal === void 0 ? void 0 : addAbortListener(signal, abort);
+		if (signal?.aborted) abort();
+		try {
+			await this.provider.shutdown();
+		} finally {
+			try {
+				await this.exporter.shutdown();
+			} finally {
+				listener?.[Symbol.dispose]();
+			}
+		}
+	}
+};
+//#endregion
+//#region lib/types/session-log.js
+/** Collector request ceiling in uncompressed UTF-8 bytes, including the OTLP envelope. */
+const SESSION_LOG_MAX_REQUEST_BYTES = 4e6;
+/**
+* Validate byte and queue settings before constructing an SDK pipeline.
+* @param options - Session-specific limits supplied by the owning composition.
+* @returns the resolved collector request limit.
+*/
+function resolveSessionLogLimits(options) {
+	const limit = options.maxRequestBytes ?? 4e6;
+	if (!Number.isSafeInteger(limit) || limit < 1 || limit > 4e6) throw new Error(`session log maxRequestBytes must be an integer between 1 and ${SESSION_LOG_MAX_REQUEST_BYTES}`);
+	for (const key of [
+		"maxQueueSize",
+		"maxExportBatchSize",
+		"scheduledDelayMillis",
+		"exportTimeoutMillis"
+	]) {
+		const value = options.processor?.[key];
+		if (value !== void 0 && (!Number.isSafeInteger(value) || value < 1 || value > 2147483647)) throw new Error(`session log processor.${key} must be a positive integer no greater than 2147483647`);
+	}
+	const queue = options.processor?.maxQueueSize ?? 2048;
+	if ((options.processor?.maxExportBatchSize ?? 512) > queue) throw new Error("session log maxExportBatchSize must not exceed maxQueueSize");
+	return limit;
+}
+/** Byte/count batching with one transport request in flight, including after a watchdog warning. */
+var SessionLogProcessor = class {
+	exporter;
+	limit;
+	config;
+	warn;
+	queue = [];
+	bytes = 0;
+	timer;
+	active;
+	shutdownPromise;
+	stopped = false;
+	constructor(exporter, limit, config, warn) {
+		this.exporter = exporter;
+		this.limit = limit;
+		this.config = config;
+		this.warn = warn;
+	}
+	onEmit(record) {
+		if (this.stopped) return;
+		if (this.queue.length >= this.config.maxQueueSize) {
+			this.warn("Session log queue is full; record rejected");
+			return;
+		}
+		let bytes;
+		try {
+			const serialized = JsonLogsSerializer.serializeRequest([record]);
+			if (serialized === void 0) throw new Error("Session log serialization produced no request");
+			bytes = serialized.byteLength;
+		} catch (error) {
+			this.warn("Session log serialization failed; record rejected", error instanceof Error ? error : new Error(String(error)));
+			return;
+		}
+		if (bytes > this.limit) {
+			this.warn("Session log record rejected; content was not truncated", /* @__PURE__ */ new Error(`Session log record exceeds maxRequestBytes: ${bytes} > ${this.limit}`));
+			return;
+		}
+		this.queue.push({
+			record,
+			bytes
+		});
+		this.bytes += bytes;
+		if (this.active !== void 0) return;
+		if (this.queue.length >= this.config.maxExportBatchSize || this.bytes >= this.limit) this.forceFlush();
+		else if (this.timer === void 0) {
+			this.timer = setTimeout(() => {
+				this.forceFlush();
+			}, this.config.scheduledDelayMillis);
+			this.timer.unref();
+		}
+	}
+	forceFlush() {
+		clearTimeout(this.timer);
+		this.timer = void 0;
+		if (this.active !== void 0) return this.active;
+		if (this.queue.length === 0) return Promise.resolve();
+		this.active = this.drain();
+		return this.active;
+	}
+	async drain() {
+		try {
+			while (!this.stopped && this.queue.length > 0) {
+				let bytes = 0;
+				let count = 0;
+				for (const entry of this.queue) {
+					if (count === this.config.maxExportBatchSize || bytes + entry.bytes > this.limit) break;
+					bytes += entry.bytes;
+					count++;
+				}
+				const records = this.queue.splice(0, count).map((entry) => entry.record);
+				this.bytes -= bytes;
+				await this.send(records);
+				await this.exporter.forceFlush();
+			}
+		} finally {
+			this.active = void 0;
+		}
+	}
+	send(records) {
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				this.warn("Session log request exceeded exportTimeoutMillis; waiting for transport settlement");
+			}, this.config.exportTimeoutMillis);
+			timer.unref();
+			const finish = (error) => {
+				clearTimeout(timer);
+				if (error !== void 0) this.warn("Session log export failed", error);
+				resolve();
+			};
+			try {
+				this.exporter.export(records, (result) => {
+					finish(result.code === ExportResultCode.SUCCESS ? void 0 : result.error ?? /* @__PURE__ */ new Error("Session log HTTP export failed"));
+				});
+			} catch (error) {
+				finish(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+	stopPending() {
+		this.stopped = true;
+		this.queue.length = 0;
+		this.bytes = 0;
+		clearTimeout(this.timer);
+		this.timer = void 0;
+	}
+	shutdown() {
+		this.shutdownPromise ??= this.forceFlush().then(() => this.exporter.shutdown());
+		return this.shutdownPromise;
+	}
+};
+/** Owns feedback-authorized Session logs; no product-event provider or queue is mounted. */
+var SessionLogReporter = class {
+	provider;
+	processor;
+	logger;
+	/** @param options - explicit transport, resource identity, queue limits, and diagnostics. */
+	constructor(options) {
+		const limit = resolveSessionLogLimits(options);
+		this.processor = new SessionLogProcessor(createLogExporter(options.exporter), limit, {
+			maxQueueSize: options.processor?.maxQueueSize ?? 2048,
+			maxExportBatchSize: options.processor?.maxExportBatchSize ?? 512,
+			scheduledDelayMillis: options.processor?.scheduledDelayMillis ?? 1e3,
+			exportTimeoutMillis: options.processor?.exportTimeoutMillis ?? 3e4
+		}, options.onFailure);
+		this.provider = new LoggerProvider({
+			logRecordLimits: {
+				attributeValueLengthLimit: Infinity,
+				attributeCountLimit: Infinity
+			},
+			resource: resourceFromAttributes(options.resourceAttributes),
+			processors: [this.processor]
+		});
+		this.logger = this.provider.getLogger(options.scope.name, options.scope.version);
+	}
+	/**
+	* Enqueue one complete event without acknowledging network delivery.
+	* @param record - event with redacted data and its original Session id.
+	*/
+	reportSessionLog(record) {
+		const severityNumber = record.severityNumber ?? SeverityNumber.INFO;
+		this.logger.emit({
+			eventName: "session-log",
+			body: "session-log",
+			timestamp: record.event.time,
+			observedTimestamp: record.event.time,
+			severityNumber,
+			severityText: SeverityNumber[severityNumber],
+			attributes: {
+				...record.attributes,
+				sessionId: record.sessionId,
+				content: JSON.stringify(record.event)
+			}
+		});
+	}
+	/** Stop queued requests after the owning backend's shutdown deadline; an active transport may still settle. */
+	stopPending() {
+		this.processor.stopPending();
+	}
+	/**
+	* Drain queued requests and release the SDK transport.
+	* @returns completion after queued requests settle and the SDK transport shuts down.
+	*/
+	shutdown() {
+		return this.provider.shutdown();
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/** Cordis entry for independent ordinary-event and Session-log OTLP channels. */
+/** Shared transport provider. Mounting creates no queue, identity, or network connection. */
+var OTel = class extends Service {
+	constructor(ctx) {
+		super(ctx, "otel");
+	}
+	/**
+	* Create an independent ordinary-event channel with count-based batching.
+	* The injected consumer must drain it during its fiber disposal.
+	* @param options - transport, scope, resource, queue, and diagnostic settings selected by the consumer.
+	* @returns the caller-owned channel; no state is shared with other channels.
+	*/
+	createEventReporter(options) {
+		return new EventLogReporter(options);
+	}
+	/**
+	* Create an independent byte-bounded Session-log channel.
+	* Authorization and redaction precede reporting; the consumer owns shutdown and its outer deadline.
+	* @param options - transport, scope, resource, queue, and diagnostic settings selected by the consumer.
+	* @returns the caller-owned channel, preserving complete accepted events within the request byte ceiling.
+	*/
+	createSessionLogReporter(options) {
+		return new SessionLogReporter(options);
+	}
+};
+//#endregion
+export { OTel as default };

package/lib/types/event-log.d.ts

@@ -0,0 +1,52 @@
+/** Ordinary event SDK batching over a cancellable HTTP transport. */
+import type { Attributes } from '@opentelemetry/api';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import type { BatchLogRecordProcessorOptions } from '@opentelemetry/sdk-logs';
+import type { SessionLogOptions } from './session-log.ts';
+/** Scalar values accepted by the collector's Arrow attributes map. */
+export type OTelEventScalar = string | number | boolean;
+/** Explicitly selected analytics fields; object values may contain scalars only. */
+export interface OTelEventRecord {
+    /** Product/DA-owned event name. */
+    eventName: string;
+    /** Human-readable summary; never a prompt, response, credential, or file contents. */
+    body: string;
+    /** Event occurrence time in Unix milliseconds. Observation time is assigned on enqueue. */
+    timestamp: number;
+    /** OTel severity; omitted values use INFO. */
+    severityNumber?: SeverityNumber;
+    /** Business fields selected by the caller; no automatic device or account identity. */
+    attributes?: Record<string, OTelEventScalar | Record<string, OTelEventScalar>>;
+}
+/** Ordinary-event transport, resource, scope, and count-batching options. */
+export interface EventLogOptions {
+    exporter: SessionLogOptions['exporter'];
+    resourceAttributes: Attributes;
+    scope: {
+        name: string;
+        version?: string;
+    };
+    processor: Omit<BatchLogRecordProcessorOptions, 'exporter'>;
+    onFailure: SessionLogOptions['onFailure'];
+}
+/** One caller-owned ordinary-event queue, independent of every Session-log queue. */
+export declare class EventLogReporter {
+    private readonly exporter;
+    private readonly provider;
+    private readonly logger;
+    private readonly cancellation;
+    /** @param options - explicit transport, resource, scope, queue, and diagnostic settings. */
+    constructor(options: EventLogOptions);
+    /**
+     * Enqueue caller-selected analytics fields without acknowledging delivery.
+     * @param record - the ordinary event to report.
+     */
+    emit(record: OTelEventRecord): void;
+    /**
+     * Drain the queue and release its transport, cancelling remaining exports when the caller aborts.
+     * @param signal - optional shutdown deadline; abort discards pending exports and cancels retry waits.
+     * @returns completion of SDK shutdown and transport cleanup.
+     */
+    shutdown(signal?: AbortSignal): Promise<void>;
+}
+//# sourceMappingURL=event-log.d.ts.map

package/lib/types/event-transport.d.ts

@@ -0,0 +1,12 @@
+import { type OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base';
+import type { LogRecordExporter } from '@opentelemetry/sdk-logs';
+/**
+ * Create a channel-owned exporter whose cancellation releases requests and retry timers.
+ * @param options - explicit collector and SDK HTTP settings.
+ * @param signal - channel cancellation, shared by current and future batch exports.
+ * @returns the SDK exporter; shutdown also destroys its owned HTTP agent.
+ */
+export declare function createEventLogExporter(options: OTLPExporterNodeConfigBase & {
+    url: string;
+}, signal: AbortSignal): LogRecordExporter;
+//# sourceMappingURL=event-transport.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,30 @@
+/** Cordis entry for independent ordinary-event and Session-log OTLP channels. */
+import { Context, Service } from '@deepseek-ai/cordis';
+import { EventLogReporter, type EventLogOptions } from './event-log.ts';
+import { SessionLogReporter, type SessionLogOptions } from './session-log.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        otel: OTel;
+    }
+}
+/** Shared transport provider. Mounting creates no queue, identity, or network connection. */
+export default class OTel extends Service {
+    constructor(ctx: Context);
+    /**
+     * Create an independent ordinary-event channel with count-based batching.
+     * The injected consumer must drain it during its fiber disposal.
+     * @param options - transport, scope, resource, queue, and diagnostic settings selected by the consumer.
+     * @returns the caller-owned channel; no state is shared with other channels.
+     */
+    createEventReporter(options: EventLogOptions): EventLogReporter;
+    /**
+     * Create an independent byte-bounded Session-log channel.
+     * Authorization and redaction precede reporting; the consumer owns shutdown and its outer deadline.
+     * @param options - transport, scope, resource, queue, and diagnostic settings selected by the consumer.
+     * @returns the caller-owned channel, preserving complete accepted events within the request byte ceiling.
+     */
+    createSessionLogReporter(options: SessionLogOptions): SessionLogReporter;
+}
+export type { EventLogOptions, OTelEventRecord, OTelEventScalar, EventLogReporter } from './event-log.ts';
+export type { SessionLogRecord, SessionLogOptions, SessionLogReporter } from './session-log.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/session-log.d.ts

@@ -0,0 +1,68 @@
+/** Session-log records in an independent byte-bounded OTLP queue. */
+import type { SessionEvent, SessionId } from '@deepseek-ai/dsh-session';
+import type { Attributes } from '@opentelemetry/api';
+import { SeverityNumber } from '@opentelemetry/api-logs';
+import type { OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base';
+import { type BatchLogRecordProcessorOptions } from '@opentelemetry/sdk-logs';
+/** Collector request ceiling in uncompressed UTF-8 bytes, including the OTLP envelope. */
+export declare const SESSION_LOG_MAX_REQUEST_BYTES = 4000000;
+/** One canonical event with its separately owned Session identity and redacted payload. */
+export interface SessionLogRecord {
+    sessionId: SessionId;
+    /** Complete event envelope; data is the capture policy's exported copy. */
+    event: Omit<SessionEvent, 'data'> & {
+        data: unknown;
+    };
+    /** Additional capture metadata; sessionId and content are always assigned by the reporter. */
+    attributes?: Attributes;
+    /** Omitted values use INFO. */
+    severityNumber?: SeverityNumber;
+}
+/** Session-log transport and byte/count queue settings. */
+export interface SessionLogOptions {
+    /** Explicit destination and SDK transport options. */
+    exporter: OTLPExporterNodeConfigBase & {
+        /** Full HTTP(S) logs destination. */
+        url: string;
+    };
+    /** Session-only queue settings, independent of product-event aggregation. */
+    processor?: Omit<BatchLogRecordProcessorOptions, 'exporter'>;
+    /** May lower, but never exceed, the collector's 4,000,000-byte limit. */
+    maxRequestBytes?: number;
+    /** Instrumentation scope supplied by the business owner. */
+    scope: {
+        name: string;
+        version?: string;
+    };
+    /** Application and anonymous identity carried on the OTLP resource. */
+    resourceAttributes: Attributes;
+    /** Report rejected single records and network failures without recording their content. */
+    onFailure: (message: string, error?: Error) => void;
+}
+/**
+ * Validate byte and queue settings before constructing an SDK pipeline.
+ * @param options - Session-specific limits supplied by the owning composition.
+ * @returns the resolved collector request limit.
+ */
+export declare function resolveSessionLogLimits(options: Pick<SessionLogOptions, 'maxRequestBytes' | 'processor'>): number;
+/** Owns feedback-authorized Session logs; no product-event provider or queue is mounted. */
+export declare class SessionLogReporter {
+    private readonly provider;
+    private readonly processor;
+    private readonly logger;
+    /** @param options - explicit transport, resource identity, queue limits, and diagnostics. */
+    constructor(options: SessionLogOptions);
+    /**
+     * Enqueue one complete event without acknowledging network delivery.
+     * @param record - event with redacted data and its original Session id.
+     */
+    reportSessionLog(record: SessionLogRecord): void;
+    /** Stop queued requests after the owning backend's shutdown deadline; an active transport may still settle. */
+    stopPending(): void;
+    /**
+     * Drain queued requests and release the SDK transport.
+     * @returns completion after queued requests settle and the SDK transport shuts down.
+     */
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=session-log.d.ts.map

package/lib/types/transport.d.ts

@@ -0,0 +1,21 @@
+/** Explicit OTLP JSON transport for feedback-authorized Session logs. */
+import { createOtlpHttpExportDelegate } from '@opentelemetry/otlp-exporter-base/node-http';
+import { type OTLPExporterNodeConfigBase } from '@opentelemetry/otlp-exporter-base';
+import type { LogRecordExporter } from '@opentelemetry/sdk-logs';
+/**
+ * Create an SDK JSON exporter without inheriting another collector's headers or TLS identity.
+ * @param options - explicit endpoint, headers, agent, and SDK transport settings.
+ * @returns the exporter owned by one independent log pipeline.
+ */
+export declare function createLogExporter(options: OTLPExporterNodeConfigBase & {
+    url: string;
+}): LogRecordExporter;
+/**
+ * Resolve collector-local headers and agents with shared SDK timeout and compression defaults.
+ * @param options - explicit endpoint and SDK HTTP settings.
+ * @returns resolved transport settings without ambient credentials.
+ */
+export declare function logTransportOptions(options: OTLPExporterNodeConfigBase & {
+    url: string;
+}): Parameters<typeof createOtlpHttpExportDelegate>[0];
+//# sourceMappingURL=transport.d.ts.map

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@deepseek-ai/dsh-otel",
+  "description": "Cordis service for independent ordinary-event and byte-bounded Session-log OTLP channels",
+  "version": "0.2.0-rc.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/telemetry/otel"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/api-logs": "^0.220.0",
+    "@opentelemetry/otlp-exporter-base": "^0.220.0",
+    "@opentelemetry/resources": "^2.9.0",
+    "@opentelemetry/sdk-logs": "^0.220.0",
+    "@opentelemetry/core": "2.9.0",
+    "@opentelemetry/otlp-transformer": "^0.220.0",
+    "got": "^14.6.6"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "~4.0.4",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.1"
+  }
+}