@clinebot/core 0.0.28 → 0.0.30

package/src/telemetry/OpenTelemetryAdapter.ts

@@ -229,8 +229,8 @@ export class OpenTelemetryAdapter implements ITelemetryAdapter {
 	): TelemetryProperties {
 		return {
 			...this.commonProperties,
-			...properties,
 			...this.metadata,
+			...properties,
 			...(this.distinctId ? { distinct_id: this.distinctId } : {}),
 			...(required ? { _required: true } : {}),
 		};

package/src/telemetry/OpenTelemetryProvider.test.ts

@@ -52,6 +52,29 @@ describe("createOpenTelemetryTelemetryService", () => {
 		await provider.dispose();
 	});
 
+	it("registers a tracer provider when tracesExporter is set", async () => {
+		const { provider } = createOpenTelemetryTelemetryService({
+			metadata: {
+				extension_version: "1.2.3",
+				cline_type: "cli",
+				platform: "terminal",
+				platform_version: process.version,
+				os_type: process.platform,
+				os_version: "unknown",
+			},
+			enabled: true,
+			tracesExporter: "console",
+			logsExporter: "console",
+			metricsExporter: "console",
+			serviceName: "cline-test",
+		});
+
+		expect(provider.tracerProvider).not.toBeNull();
+		const span = provider.getTracer("test").startSpan("verify.tracing");
+		span.end();
+		await provider.dispose();
+	});
+
 	it("does not create an OTEL provider when disabled", () => {
 		const providerSpy = vi.spyOn(
 			OpenTelemetryProvider.prototype,
@@ -75,11 +98,201 @@ describe("createOpenTelemetryTelemetryService", () => {
 		expect(telemetry).toBeInstanceOf(TelemetryService);
 	});
 
+	it("preserves metadata when disabled", () => {
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+		const { telemetry } = createConfiguredTelemetryService({
+			metadata,
+			enabled: false,
+		});
+		const spy = vi.fn();
+		(telemetry as any).adapters.push({
+			name: "test",
+			emit: spy,
+			emitRequired: spy,
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: async () => {},
+			dispose: async () => {},
+		});
+		telemetry.captureRequired("test.event", {});
+		expect(spy).toHaveBeenCalledWith(
+			"test.event",
+			expect.objectContaining({
+				cline_type: "kanban",
+				platform: "kanban",
+			}),
+		);
+	});
+
+	it("preserves metadata in the enabled (OTEL) path", async () => {
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+		const { telemetry, provider } = createOpenTelemetryTelemetryService({
+			metadata,
+			enabled: true,
+			logsExporter: "console",
+		});
+		const spy = vi.fn();
+		(telemetry as any).adapters.push({
+			name: "test",
+			emit: spy,
+			emitRequired: spy,
+			isEnabled: () => true,
+			recordCounter: vi.fn(),
+			recordHistogram: vi.fn(),
+			recordGauge: vi.fn(),
+			flush: async () => {},
+			dispose: async () => {},
+		});
+		telemetry.captureRequired("test.event", {});
+		expect(spy).toHaveBeenCalledWith(
+			"test.event",
+			expect.objectContaining({
+				cline_type: "kanban",
+				platform: "kanban",
+			}),
+		);
+		await provider.dispose();
+	});
+
+	it("delivers metadata to the OTEL logger without duplication", async () => {
+		const otelEmit = vi.fn();
+		const provider = new OpenTelemetryProvider({
+			enabled: true,
+		});
+		// Replace the loggerProvider with a mock so we can inspect emit calls
+		(provider as any).loggerProvider = {
+			getLogger: () => ({ emit: otelEmit }),
+			forceFlush: async () => {},
+			shutdown: async () => {},
+		};
+
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+
+		const telemetry = provider.createTelemetryService({ metadata });
+
+		telemetry.captureRequired("test.otel_event", { custom_prop: "value" });
+
+		expect(otelEmit).toHaveBeenCalledTimes(1);
+		const emittedAttributes = otelEmit.mock.calls[0][0].attributes;
+
+		// Metadata fields must be present
+		expect(emittedAttributes).toMatchObject({
+			cline_type: "kanban",
+			platform: "kanban",
+			extension_version: "1.0.0",
+			custom_prop: "value",
+		});
+
+		// Verify no key appears more than once (flattened object can't have
+		// duplicate keys, but this guards against nested duplication patterns
+		// like metadata appearing under a sub-prefix)
+		const keys = Object.keys(emittedAttributes);
+		const metadataKeys = Object.keys(metadata);
+		for (const mk of metadataKeys) {
+			const occurrences = keys.filter((k) => k === mk || k.endsWith(`.${mk}`));
+			expect(
+				occurrences,
+				`metadata key "${mk}" should appear exactly once, found: ${occurrences.join(", ")}`,
+			).toHaveLength(1);
+		}
+
+		await provider.dispose();
+	});
+
+	it("propagates updateMetadata to OTEL logger output", async () => {
+		const otelEmit = vi.fn();
+		const provider = new OpenTelemetryProvider({
+			enabled: true,
+		});
+		(provider as any).loggerProvider = {
+			getLogger: () => ({ emit: otelEmit }),
+			forceFlush: async () => {},
+			shutdown: async () => {},
+		};
+
+		const metadata = {
+			extension_version: "1.0.0",
+			cline_type: "kanban",
+			platform: "kanban",
+			platform_version: "v22.0.0",
+			os_type: "darwin",
+			os_version: "15.0",
+		};
+
+		const telemetry = provider.createTelemetryService({ metadata });
+
+		// Update metadata after construction
+		telemetry.updateMetadata({ cline_type: "kanban-updated" });
+
+		telemetry.captureRequired("test.updated_event", {});
+
+		// The OTEL logger should see the updated value
+		const emittedAttributes =
+			otelEmit.mock.calls[otelEmit.mock.calls.length - 1][0].attributes;
+		expect(emittedAttributes.cline_type).toBe("kanban-updated");
+
+		await provider.dispose();
+	});
+
+	it("preserves logger when disabled", () => {
+		const logger: BasicLogger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+			error: vi.fn(),
+		};
+		const { telemetry } = createConfiguredTelemetryService({
+			metadata: {
+				extension_version: "1.0.0",
+				cline_type: "kanban",
+				platform: "kanban",
+				platform_version: "v22.0.0",
+				os_type: "darwin",
+				os_version: "15.0",
+			},
+			enabled: false,
+			logger,
+		});
+
+		telemetry.capture({
+			event: "session.started",
+			properties: { sessionId: "session-1" },
+		});
+
+		expect(logger.log).toHaveBeenCalledWith(
+			"telemetry.event",
+			expect.objectContaining({
+				event: "session.started",
+			}),
+		);
+	});
+
 	it("attaches the logger adapter when creating configured telemetry", () => {
 		const logger: BasicLogger = {
 			debug: vi.fn(),
-			info: vi.fn(),
-			warn: vi.fn(),
+			log: vi.fn(),
 			error: vi.fn(),
 		};
 		const { telemetry, provider } = createConfiguredTelemetryService({
@@ -101,7 +314,7 @@ describe("createOpenTelemetryTelemetryService", () => {
 			properties: { sessionId: "session-1" },
 		});
 
-		expect(logger.info).toHaveBeenCalledWith(
+		expect(logger.log).toHaveBeenCalledWith(
 			"telemetry.event",
 			expect.objectContaining({
 				event: "session.started",

package/src/telemetry/OpenTelemetryProvider.ts

@@ -4,11 +4,12 @@ import type {
 	OpenTelemetryClientConfig,
 	TelemetryMetadata,
 } from "@clinebot/shared";
-import { metrics } from "@opentelemetry/api";
+import { metrics, type Tracer, trace } from "@opentelemetry/api";
 import { logs } from "@opentelemetry/api-logs";
 import { OTLPLogExporter as OTLPLogExporterHttp } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPMetricExporter as OTLPMetricExporterHttp } from "@opentelemetry/exporter-metrics-otlp-http";
-import { Resource } from "@opentelemetry/resources";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
 import {
 	BatchLogRecordProcessor,
 	ConsoleLogRecordExporter,
@@ -21,6 +22,13 @@ import {
 	type MetricReader,
 	PeriodicExportingMetricReader,
 } from "@opentelemetry/sdk-metrics";
+import {
+	BatchSpanProcessor,
+	ConsoleSpanExporter,
+	SimpleSpanProcessor,
+	type SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import {
 	ATTR_SERVICE_NAME,
 	ATTR_SERVICE_VERSION,
@@ -38,13 +46,14 @@ type OpenTelemetryProtocol = "http/json";
 export interface OpenTelemetryProviderOptions
 	extends Omit<
 		OpenTelemetryClientConfig,
-		"enabled" | "logsExporter" | "metricsExporter"
+		"enabled" | "logsExporter" | "metricsExporter" | "tracesExporter"
 	> {
 	serviceName?: string;
 	serviceVersion?: string;
 	enabled?: boolean;
 	logsExporter?: string | OpenTelemetryExporterKind[];
 	metricsExporter?: string | OpenTelemetryExporterKind[];
+	tracesExporter?: string | OpenTelemetryExporterKind[];
 	metricExportIntervalMs?: number;
 	logMaxQueueSize?: number;
 	logBatchSize?: number;
@@ -64,11 +73,12 @@ export interface CreateOpenTelemetryTelemetryServiceOptions
 export class OpenTelemetryProvider {
 	readonly meterProvider: MeterProvider | null;
 	readonly loggerProvider: LoggerProvider | null;
+	readonly tracerProvider: NodeTracerProvider | null;
 	private readonly options: OpenTelemetryProviderOptions;
 
 	constructor(options: OpenTelemetryProviderOptions = {}) {
 		this.options = options;
-		const resource = new Resource({
+		const resource = resourceFromAttributes({
 			[ATTR_SERVICE_NAME]: options.serviceName ?? "cline",
 			...(options.serviceVersion
 				? { [ATTR_SERVICE_VERSION]: options.serviceVersion }
@@ -77,6 +87,7 @@ export class OpenTelemetryProvider {
 
 		this.meterProvider = this.createMeterProvider(resource);
 		this.loggerProvider = this.createLoggerProvider(resource);
+		this.tracerProvider = this.createTracerProvider(resource);
 
 		if (this.meterProvider) {
 			metrics.setGlobalMeterProvider(this.meterProvider);
@@ -84,6 +95,17 @@ export class OpenTelemetryProvider {
 		if (this.loggerProvider) {
 			logs.setGlobalLoggerProvider(this.loggerProvider);
 		}
+		if (this.tracerProvider) {
+			this.tracerProvider.register();
+		}
+	}
+
+	/**
+	 * Returns a tracer for manual spans. Requires {@link OpenTelemetryProviderOptions.tracesExporter}
+	 * so that a {@link NodeTracerProvider} is registered.
+	 */
+	getTracer(name = "cline", version?: string): Tracer {
+		return trace.getTracer(name, version ?? this.options.serviceVersion);
 	}
 
 	createAdapter(
@@ -111,10 +133,9 @@ export class OpenTelemetryProvider {
 			metadata: options.metadata,
 		});
 		return new TelemetryService({
+			...options,
 			adapters: [adapter],
 			distinctId: resolveCoreDistinctId(options.distinctId),
-			commonProperties: options.commonProperties,
-			logger: options.logger,
 		});
 	}
 
@@ -122,6 +143,7 @@ export class OpenTelemetryProvider {
 		await Promise.all([
 			this.meterProvider?.forceFlush?.(),
 			this.loggerProvider?.forceFlush?.(),
+			this.tracerProvider?.forceFlush?.(),
 		]);
 	}
 
@@ -129,10 +151,13 @@ export class OpenTelemetryProvider {
 		await Promise.all([
 			this.meterProvider?.shutdown?.(),
 			this.loggerProvider?.shutdown?.(),
+			this.tracerProvider?.shutdown?.(),
 		]);
 	}
 
-	private createMeterProvider(resource: Resource): MeterProvider | null {
+	private createMeterProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): MeterProvider | null {
 		const exporters = normalizeExporters(this.options.metricsExporter);
 		if (exporters.length === 0) {
 			return null;
@@ -168,35 +193,71 @@ export class OpenTelemetryProvider {
 		});
 	}
 
-	private createLoggerProvider(resource: Resource): LoggerProvider | null {
-		const exporters = normalizeExporters(this.options.logsExporter);
+	private createTracerProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): NodeTracerProvider | null {
+		const exporters = normalizeExporters(this.options.tracesExporter);
 		if (exporters.length === 0) {
 			return null;
 		}
 
-		const provider = new LoggerProvider({ resource });
+		const traceEndpoint =
+			this.options.otlpTracesEndpoint ?? this.options.otlpEndpoint;
+		const traceHeaders =
+			this.options.otlpTracesHeaders ?? this.options.otlpHeaders;
+
+		const processors: SpanProcessor[] = [];
 		for (const exporter of exporters) {
-			const logExporter = createLogExporter(exporter, {
-				endpoint: this.options.otlpEndpoint,
-				headers: this.options.otlpHeaders,
+			const processor = createSpanProcessor(exporter, {
+				endpoint: traceEndpoint,
+				headers: traceHeaders,
 				insecure: this.options.otlpInsecure ?? false,
 				protocol: "http/json",
 			});
-			if (!logExporter) {
-				continue;
+			if (processor) {
+				processors.push(processor);
 			}
-			provider.addLogRecordProcessor(
-				new BatchLogRecordProcessor(logExporter, {
+		}
+		if (processors.length === 0) {
+			return null;
+		}
+
+		return new NodeTracerProvider({ resource, spanProcessors: processors });
+	}
+
+	private createLoggerProvider(
+		resource: ReturnType<typeof resourceFromAttributes>,
+	): LoggerProvider | null {
+		const exporters = normalizeExporters(this.options.logsExporter);
+		if (exporters.length === 0) {
+			return null;
+		}
+
+		const processors = exporters
+			.map((exporter) => {
+				const logExporter = createLogExporter(exporter, {
+					endpoint: this.options.otlpEndpoint,
+					headers: this.options.otlpHeaders,
+					insecure: this.options.otlpInsecure ?? false,
+					protocol: "http/json",
+				});
+				if (!logExporter) {
+					return null;
+				}
+				return new BatchLogRecordProcessor(logExporter, {
 					maxQueueSize: this.options.logMaxQueueSize ?? 2048,
 					maxExportBatchSize: this.options.logBatchSize ?? 512,
 					scheduledDelayMillis:
 						this.options.logBatchTimeoutMs ??
 						this.options.logBatchTimeout ??
 						5000,
-				}),
-			);
+				});
+			})
+			.filter((p): p is BatchLogRecordProcessor => p !== null);
+		if (processors.length === 0) {
+			return null;
 		}
-		return provider;
+		return new LoggerProvider({ resource, processors });
 	}
 }
 
@@ -214,6 +275,9 @@ export function createOpenTelemetryTelemetryService(
 		metricsExporter: Array.isArray(options.metricsExporter)
 			? options.metricsExporter.join(",")
 			: options.metricsExporter,
+		tracesExporter: Array.isArray(options.tracesExporter)
+			? options.tracesExporter.join(",")
+			: options.tracesExporter,
 		otlpProtocol: options.otlpProtocol,
 		hasOtlpEndpoint: Boolean(options.otlpEndpoint),
 		serviceName: options.serviceName,
@@ -234,6 +298,7 @@ export function createConfiguredTelemetryService(
 	if (options.enabled !== true) {
 		return {
 			telemetry: new TelemetryService({
+				...options,
 				distinctId: resolveCoreDistinctId(options.distinctId),
 			}),
 		};
@@ -280,6 +345,31 @@ function createLogExporter(
 	});
 }
 
+function createSpanProcessor(
+	exporter: OpenTelemetryExporterKind,
+	options: {
+		endpoint?: string;
+		headers?: Record<string, string>;
+		insecure: boolean;
+		protocol: OpenTelemetryProtocol;
+	},
+): SpanProcessor | null {
+	if (exporter === "console") {
+		return new SimpleSpanProcessor(new ConsoleSpanExporter());
+	}
+	if (!options.endpoint) {
+		return null;
+	}
+
+	const endpoint = ensurePathSuffix(options.endpoint, "/v1/traces");
+	return new BatchSpanProcessor(
+		new OTLPTraceExporter({
+			url: endpoint,
+			headers: options.headers,
+		}),
+	);
+}
+
 function createMetricReader(
 	exporter: OpenTelemetryExporterKind,
 	options: {

package/src/telemetry/TelemetryLoggerSink.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
+
+describe("TelemetryLoggerSink", () => {
+	it("logs events and metrics through the provided logger", async () => {
+		const logger = {
+			debug: vi.fn(),
+			log: vi.fn(),
+		};
+		const sink = new TelemetryLoggerSink({ logger });
+
+		sink.emit("session.started", { sessionId: "s1" });
+		sink.emitRequired("user.opt_out", { reason: "manual" });
+		sink.recordCounter("cline.session.starts.total", 1, {
+			sessionId: "s1",
+		});
+
+		expect(logger.log).toHaveBeenCalledWith("telemetry.event", {
+			telemetrySink: "TelemetryLoggerSink",
+			event: "session.started",
+			properties: { sessionId: "s1" },
+		});
+		expect(logger.log).toHaveBeenCalledWith("telemetry.required_event", {
+			telemetrySink: "TelemetryLoggerSink",
+			severity: "warn",
+			event: "user.opt_out",
+			properties: { reason: "manual" },
+		});
+		expect(logger.debug).toHaveBeenCalledWith("telemetry.metric", {
+			telemetrySink: "TelemetryLoggerSink",
+			instrument: "counter",
+			name: "cline.session.starts.total",
+			value: 1,
+			attributes: { sessionId: "s1" },
+			description: undefined,
+			required: false,
+		});
+
+		await sink.flush();
+		await sink.dispose();
+	});
+});

package/src/telemetry/{LoggerTelemetryAdapter.ts → TelemetryLoggerSink.ts}

@@ -4,20 +4,26 @@ import type {
 	TelemetryProperties,
 } from "./ITelemetryAdapter";
 
-export interface LoggerTelemetryAdapterOptions {
+/**
+ * {@link ITelemetryAdapter} implementation that forwards telemetry to a {@link BasicLogger}.
+ *
+ * This is intentionally named *Sink* (not "adapter") to distinguish it from host logging bridges
+ * such as the CLI Pino bundle: it consumes telemetry events and writes them to the injected logger.
+ */
+export interface TelemetryLoggerSinkOptions {
 	logger?: BasicLogger;
 	name?: string;
 	enabled?: boolean | (() => boolean);
 }
 
-export class LoggerTelemetryAdapter implements ITelemetryAdapter {
+export class TelemetryLoggerSink implements ITelemetryAdapter {
 	readonly name: string;
 
 	private readonly logger?: BasicLogger;
 	private readonly enabled: boolean | (() => boolean);
 
-	constructor(options: LoggerTelemetryAdapterOptions = {}) {
-		this.name = options.name ?? "LoggerTelemetryAdapter";
+	constructor(options: TelemetryLoggerSinkOptions = {}) {
+		this.name = options.name ?? "TelemetryLoggerSink";
 		this.logger = options.logger;
 		this.enabled = options.enabled ?? true;
 	}
@@ -26,16 +32,17 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!this.isEnabled()) {
 			return;
 		}
-		this.logger?.info?.("telemetry.event", {
-			adapter: this.name,
+		this.logger?.log("telemetry.event", {
+			telemetrySink: this.name,
 			event,
 			properties,
 		});
 	}
 
 	emitRequired(event: string, properties?: TelemetryProperties): void {
-		this.logger?.warn?.("telemetry.required_event", {
-			adapter: this.name,
+		this.logger?.log("telemetry.required_event", {
+			telemetrySink: this.name,
+			severity: "warn",
 			event,
 			properties,
 		});
@@ -51,8 +58,8 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!required && !this.isEnabled()) {
 			return;
 		}
-		this.logger?.debug?.("telemetry.metric", {
-			adapter: this.name,
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
 			instrument: "counter",
 			name,
 			value,
@@ -72,8 +79,8 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!required && !this.isEnabled()) {
 			return;
 		}
-		this.logger?.debug?.("telemetry.metric", {
-			adapter: this.name,
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
 			instrument: "histogram",
 			name,
 			value,
@@ -93,8 +100,8 @@ export class LoggerTelemetryAdapter implements ITelemetryAdapter {
 		if (!required && !this.isEnabled()) {
 			return;
 		}
-		this.logger?.debug?.("telemetry.metric", {
-			adapter: this.name,
+		this.logger?.debug("telemetry.metric", {
+			telemetrySink: this.name,
 			instrument: "gauge",
 			name,
 			value,

package/src/telemetry/TelemetryService.test.ts

@@ -53,8 +53,7 @@ describe("TelemetryService", () => {
 	it("mirrors telemetry events into the logger when provided", () => {
 		const logger: BasicLogger = {
 			debug: vi.fn(),
-			info: vi.fn(),
-			warn: vi.fn(),
+			log: vi.fn(),
 			error: vi.fn(),
 		};
 		const service = new TelemetryService({
@@ -75,10 +74,10 @@ describe("TelemetryService", () => {
 			sessionId: "session-1",
 		});
 
-		expect(logger.info).toHaveBeenCalledWith(
+		expect(logger.log).toHaveBeenCalledWith(
 			"telemetry.event",
 			expect.objectContaining({
-				adapter: "LoggerTelemetryAdapter",
+				telemetrySink: "TelemetryLoggerSink",
 				event: "session.started",
 				properties: expect.objectContaining({
 					sessionId: "session-1",
@@ -87,10 +86,11 @@ describe("TelemetryService", () => {
 				}),
 			}),
 		);
-		expect(logger.warn).toHaveBeenCalledWith(
+		expect(logger.log).toHaveBeenCalledWith(
 			"telemetry.required_event",
 			expect.objectContaining({
-				adapter: "LoggerTelemetryAdapter",
+				telemetrySink: "TelemetryLoggerSink",
+				severity: "warn",
 				event: "user.opt_out",
 				properties: expect.objectContaining({
 					reason: "manual",
@@ -101,7 +101,7 @@ describe("TelemetryService", () => {
 		expect(logger.debug).toHaveBeenCalledWith(
 			"telemetry.metric",
 			expect.objectContaining({
-				adapter: "LoggerTelemetryAdapter",
+				telemetrySink: "TelemetryLoggerSink",
 				instrument: "counter",
 				name: "cline.session.starts.total",
 			}),

package/src/telemetry/TelemetryService.ts

@@ -5,7 +5,7 @@ import type {
 	TelemetryProperties,
 } from "@clinebot/shared";
 import type { ITelemetryAdapter } from "./ITelemetryAdapter";
-import { LoggerTelemetryAdapter } from "./LoggerTelemetryAdapter";
+import { TelemetryLoggerSink } from "./TelemetryLoggerSink";
 
 export interface TelemetryServiceOptions {
 	adapters?: ITelemetryAdapter[];
@@ -24,9 +24,7 @@ export class TelemetryService implements ITelemetryService {
 	constructor(options: TelemetryServiceOptions = {}) {
 		this.adapters = [...(options.adapters ?? [])];
 		if (options.logger) {
-			this.adapters.push(
-				new LoggerTelemetryAdapter({ logger: options.logger }),
-			);
+			this.adapters.push(new TelemetryLoggerSink({ logger: options.logger }));
 		}
 		this.metadata = { ...(options.metadata ?? {}) };
 		this.distinctId = options.distinctId;