@logtape/otel 1.3.0-dev.379 → 1.3.0-dev.381

package/deno.json

@@ -1,18 +1,20 @@
 {
   "name": "@logtape/otel",
-  "version": "1.3.0-dev.379+84654e7a",
+  "version": "1.3.0-dev.381+eef5c598",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts"
   },
   "imports": {
     "@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
-    "@opentelemetry/api-logs": "npm:@opentelemetry/api-logs@^0.202.0",
-    "@opentelemetry/exporter-logs-otlp-http": "npm:@opentelemetry/exporter-logs-otlp-http@^0.202.0",
-    "@opentelemetry/otlp-exporter-base": "npm:@opentelemetry/otlp-exporter-base@^0.202.0",
-    "@opentelemetry/resources": "npm:@opentelemetry/resources@^2.0.1",
-    "@opentelemetry/sdk-logs": "npm:@opentelemetry/sdk-logs@^0.202.0",
-    "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.34.0"
+    "@opentelemetry/api-logs": "npm:@opentelemetry/api-logs@^0.208.0",
+    "@opentelemetry/exporter-logs-otlp-grpc": "npm:@opentelemetry/exporter-logs-otlp-grpc@^0.208.0",
+    "@opentelemetry/exporter-logs-otlp-http": "npm:@opentelemetry/exporter-logs-otlp-http@^0.208.0",
+    "@opentelemetry/exporter-logs-otlp-proto": "npm:@opentelemetry/exporter-logs-otlp-proto@^0.208.0",
+    "@opentelemetry/otlp-exporter-base": "npm:@opentelemetry/otlp-exporter-base@^0.208.0",
+    "@opentelemetry/resources": "npm:@opentelemetry/resources@^2.2.0",
+    "@opentelemetry/sdk-logs": "npm:@opentelemetry/sdk-logs@^0.208.0",
+    "@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.38.0"
   },
   "tasks": {
     "build": "pnpm build",

package/dist/deno.cjs

@@ -1,17 +1,19 @@
 
 //#region deno.json
 var name = "@logtape/otel";
-var version = "1.3.0-dev.379+84654e7a";
+var version = "1.3.0-dev.381+eef5c598";
 var license = "MIT";
 var exports$1 = { ".": "./src/mod.ts" };
 var imports = {
 	"@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
-	"@opentelemetry/api-logs": "npm:@opentelemetry/api-logs@^0.202.0",
-	"@opentelemetry/exporter-logs-otlp-http": "npm:@opentelemetry/exporter-logs-otlp-http@^0.202.0",
-	"@opentelemetry/otlp-exporter-base": "npm:@opentelemetry/otlp-exporter-base@^0.202.0",
-	"@opentelemetry/resources": "npm:@opentelemetry/resources@^2.0.1",
-	"@opentelemetry/sdk-logs": "npm:@opentelemetry/sdk-logs@^0.202.0",
-	"@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.34.0"
+	"@opentelemetry/api-logs": "npm:@opentelemetry/api-logs@^0.208.0",
+	"@opentelemetry/exporter-logs-otlp-grpc": "npm:@opentelemetry/exporter-logs-otlp-grpc@^0.208.0",
+	"@opentelemetry/exporter-logs-otlp-http": "npm:@opentelemetry/exporter-logs-otlp-http@^0.208.0",
+	"@opentelemetry/exporter-logs-otlp-proto": "npm:@opentelemetry/exporter-logs-otlp-proto@^0.208.0",
+	"@opentelemetry/otlp-exporter-base": "npm:@opentelemetry/otlp-exporter-base@^0.208.0",
+	"@opentelemetry/resources": "npm:@opentelemetry/resources@^2.2.0",
+	"@opentelemetry/sdk-logs": "npm:@opentelemetry/sdk-logs@^0.208.0",
+	"@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.38.0"
 };
 var tasks = {
 	"build": "pnpm build",

package/dist/deno.js

@@ -1,16 +1,18 @@
 //#region deno.json
 var name = "@logtape/otel";
-var version = "1.3.0-dev.379+84654e7a";
+var version = "1.3.0-dev.381+eef5c598";
 var license = "MIT";
 var exports = { ".": "./src/mod.ts" };
 var imports = {
 	"@opentelemetry/api": "npm:@opentelemetry/api@^1.9.0",
-	"@opentelemetry/api-logs": "npm:@opentelemetry/api-logs@^0.202.0",
-	"@opentelemetry/exporter-logs-otlp-http": "npm:@opentelemetry/exporter-logs-otlp-http@^0.202.0",
-	"@opentelemetry/otlp-exporter-base": "npm:@opentelemetry/otlp-exporter-base@^0.202.0",
-	"@opentelemetry/resources": "npm:@opentelemetry/resources@^2.0.1",
-	"@opentelemetry/sdk-logs": "npm:@opentelemetry/sdk-logs@^0.202.0",
-	"@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.34.0"
+	"@opentelemetry/api-logs": "npm:@opentelemetry/api-logs@^0.208.0",
+	"@opentelemetry/exporter-logs-otlp-grpc": "npm:@opentelemetry/exporter-logs-otlp-grpc@^0.208.0",
+	"@opentelemetry/exporter-logs-otlp-http": "npm:@opentelemetry/exporter-logs-otlp-http@^0.208.0",
+	"@opentelemetry/exporter-logs-otlp-proto": "npm:@opentelemetry/exporter-logs-otlp-proto@^0.208.0",
+	"@opentelemetry/otlp-exporter-base": "npm:@opentelemetry/otlp-exporter-base@^0.208.0",
+	"@opentelemetry/resources": "npm:@opentelemetry/resources@^2.2.0",
+	"@opentelemetry/sdk-logs": "npm:@opentelemetry/sdk-logs@^0.208.0",
+	"@opentelemetry/semantic-conventions": "npm:@opentelemetry/semantic-conventions@^1.38.0"
 };
 var tasks = {
 	"build": "pnpm build",

package/dist/deno.js.map

@@ -1 +1 @@
-{"version":3,"file":"deno.js","names":[],"sources":["../deno.json"],"sourcesContent":["{\n  \"name\": \"@logtape/otel\",\n  \"version\": \"1.3.0-dev.379+84654e7a\",\n  \"license\": \"MIT\",\n  \"exports\": {\n    \".\": \"./src/mod.ts\"\n  },\n  \"imports\": {\n    \"@opentelemetry/api\": \"npm:@opentelemetry/api@^1.9.0\",\n    \"@opentelemetry/api-logs\": \"npm:@opentelemetry/api-logs@^0.202.0\",\n    \"@opentelemetry/exporter-logs-otlp-http\": \"npm:@opentelemetry/exporter-logs-otlp-http@^0.202.0\",\n    \"@opentelemetry/otlp-exporter-base\": \"npm:@opentelemetry/otlp-exporter-base@^0.202.0\",\n    \"@opentelemetry/resources\": \"npm:@opentelemetry/resources@^2.0.1\",\n    \"@opentelemetry/sdk-logs\": \"npm:@opentelemetry/sdk-logs@^0.202.0\",\n    \"@opentelemetry/semantic-conventions\": \"npm:@opentelemetry/semantic-conventions@^1.34.0\"\n  },\n  \"tasks\": {\n    \"build\": \"pnpm build\",\n    \"test\": \"deno test --allow-net --allow-env\"\n  }\n}\n"],"mappings":";WACU;cACG;cACA;cACA,EACT,KAAK,eACN;cACU;CACT,sBAAsB;CACtB,2BAA2B;CAC3B,0CAA0C;CAC1C,qCAAqC;CACrC,4BAA4B;CAC5B,2BAA2B;CAC3B,uCAAuC;AACxC;YACQ;CACP,SAAS;CACT,QAAQ;AACT;mBAnBH;;;;;;;AAoBC"}
+{"version":3,"file":"deno.js","names":[],"sources":["../deno.json"],"sourcesContent":["{\n  \"name\": \"@logtape/otel\",\n  \"version\": \"1.3.0-dev.381+eef5c598\",\n  \"license\": \"MIT\",\n  \"exports\": {\n    \".\": \"./src/mod.ts\"\n  },\n  \"imports\": {\n    \"@opentelemetry/api\": \"npm:@opentelemetry/api@^1.9.0\",\n    \"@opentelemetry/api-logs\": \"npm:@opentelemetry/api-logs@^0.208.0\",\n    \"@opentelemetry/exporter-logs-otlp-grpc\": \"npm:@opentelemetry/exporter-logs-otlp-grpc@^0.208.0\",\n    \"@opentelemetry/exporter-logs-otlp-http\": \"npm:@opentelemetry/exporter-logs-otlp-http@^0.208.0\",\n    \"@opentelemetry/exporter-logs-otlp-proto\": \"npm:@opentelemetry/exporter-logs-otlp-proto@^0.208.0\",\n    \"@opentelemetry/otlp-exporter-base\": \"npm:@opentelemetry/otlp-exporter-base@^0.208.0\",\n    \"@opentelemetry/resources\": \"npm:@opentelemetry/resources@^2.2.0\",\n    \"@opentelemetry/sdk-logs\": \"npm:@opentelemetry/sdk-logs@^0.208.0\",\n    \"@opentelemetry/semantic-conventions\": \"npm:@opentelemetry/semantic-conventions@^1.38.0\"\n  },\n  \"tasks\": {\n    \"build\": \"pnpm build\",\n    \"test\": \"deno test --allow-net --allow-env\"\n  }\n}\n"],"mappings":";WACU;cACG;cACA;cACA,EACT,KAAK,eACN;cACU;CACT,sBAAsB;CACtB,2BAA2B;CAC3B,0CAA0C;CAC1C,0CAA0C;CAC1C,2CAA2C;CAC3C,qCAAqC;CACrC,4BAA4B;CAC5B,2BAA2B;CAC3B,uCAAuC;AACxC;YACQ;CACP,SAAS;CACT,QAAQ;AACT;mBArBH;;;;;;;AAsBC"}

package/dist/mod.cjs

@@ -3,7 +3,6 @@ const require_deno = require('./deno.cjs');
 const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
 const __opentelemetry_api = require_rolldown_runtime.__toESM(require("@opentelemetry/api"));
 const __opentelemetry_api_logs = require_rolldown_runtime.__toESM(require("@opentelemetry/api-logs"));
-const __opentelemetry_exporter_logs_otlp_http = require_rolldown_runtime.__toESM(require("@opentelemetry/exporter-logs-otlp-http"));
 const __opentelemetry_resources = require_rolldown_runtime.__toESM(require("@opentelemetry/resources"));
 const __opentelemetry_sdk_logs = require_rolldown_runtime.__toESM(require("@opentelemetry/sdk-logs"));
 const __opentelemetry_semantic_conventions = require_rolldown_runtime.__toESM(require("@opentelemetry/semantic-conventions"));
@@ -24,39 +23,160 @@ function getEnvironmentVariable(name) {
 	return void 0;
 }
 /**
+* Checks if an OTLP endpoint is configured via environment variables or options.
+* Checks the following environment variables:
+* - `OTEL_EXPORTER_OTLP_LOGS_ENDPOINT` (logs-specific endpoint)
+* - `OTEL_EXPORTER_OTLP_ENDPOINT` (general OTLP endpoint)
+*
+* @param config Optional exporter configuration that may contain a URL.
+* @returns `true` if an endpoint is configured, `false` otherwise.
+*/
+function hasOtlpEndpoint(config) {
+	if (config?.url) return true;
+	const logsEndpoint = getEnvironmentVariable("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT");
+	if (logsEndpoint) return true;
+	const endpoint = getEnvironmentVariable("OTEL_EXPORTER_OTLP_ENDPOINT");
+	if (endpoint) return true;
+	return false;
+}
+/**
+* Detects the OTLP protocol from environment variables.
+* Priority:
+* 1. `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL`
+* 2. `OTEL_EXPORTER_OTLP_PROTOCOL`
+* 3. Default: `"http/json"` (for backward compatibility)
+*
+* @returns The detected OTLP protocol.
+*/
+function detectOtlpProtocol() {
+	const logsProtocol = getEnvironmentVariable("OTEL_EXPORTER_OTLP_LOGS_PROTOCOL");
+	if (logsProtocol === "grpc" || logsProtocol === "http/protobuf" || logsProtocol === "http/json") return logsProtocol;
+	const protocol = getEnvironmentVariable("OTEL_EXPORTER_OTLP_PROTOCOL");
+	if (protocol === "grpc" || protocol === "http/protobuf" || protocol === "http/json") return protocol;
+	return "http/json";
+}
+/**
+* Creates an OTLP log exporter based on the detected protocol.
+* Uses dynamic imports to maintain browser compatibility when gRPC is not used.
+* @param config Optional exporter configuration.
+* @returns A promise that resolves to the appropriate OTLP log exporter.
+*/
+async function createOtlpExporter(config) {
+	const protocol = detectOtlpProtocol();
+	switch (protocol) {
+		case "grpc": {
+			const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-grpc");
+			return new OTLPLogExporter(config);
+		}
+		case "http/protobuf": {
+			const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-proto");
+			return new OTLPLogExporter(config);
+		}
+		case "http/json":
+		default: {
+			const { OTLPLogExporter } = await import("@opentelemetry/exporter-logs-otlp-http");
+			return new OTLPLogExporter(config);
+		}
+	}
+}
+/**
+* A no-op logger provider that returns NOOP_LOGGER for all requests.
+* Used when no OTLP endpoint is configured to avoid repeated connection errors.
+*/
+const noopLoggerProvider = { getLogger: () => __opentelemetry_api_logs.NOOP_LOGGER };
+/**
+* Initializes the logger provider asynchronously.
+* This is used when the user doesn't provide a custom logger provider.
+*
+* If no OTLP endpoint is configured (via options or environment variables),
+* returns a noop logger provider to avoid repeated connection errors.
+*
+* @param options The exporter options.
+* @returns A promise that resolves to the initialized logger provider.
+*/
+async function initializeLoggerProvider(options) {
+	if (!hasOtlpEndpoint(options.otlpExporterConfig)) return noopLoggerProvider;
+	const resource = (0, __opentelemetry_resources.defaultResource)().merge((0, __opentelemetry_resources.resourceFromAttributes)({ [__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: options.serviceName ?? getEnvironmentVariable("OTEL_SERVICE_NAME") }));
+	const otlpExporter = await createOtlpExporter(options.otlpExporterConfig);
+	const loggerProvider = new __opentelemetry_sdk_logs.LoggerProvider({
+		resource,
+		processors: [new __opentelemetry_sdk_logs.SimpleLogRecordProcessor(otlpExporter)]
+	});
+	return loggerProvider;
+}
+/**
+* Emits a log record to the OpenTelemetry logger.
+* @param logger The OpenTelemetry logger.
+* @param record The LogTape log record.
+* @param options The sink options.
+*/
+function emitLogRecord(logger, record, options) {
+	const objectRenderer = options.objectRenderer ?? "inspect";
+	const { category, level, message, timestamp, properties } = record;
+	const severityNumber = mapLevelToSeverityNumber(level);
+	const attributes = convertToAttributes(properties, objectRenderer);
+	attributes["category"] = [...category];
+	logger.emit({
+		severityNumber,
+		severityText: level,
+		body: typeof options.messageType === "function" ? convertMessageToCustomBodyFormat(message, objectRenderer, options.messageType) : options.messageType === "array" ? convertMessageToArray(message, objectRenderer) : convertMessageToString(message, objectRenderer),
+		attributes,
+		timestamp: new Date(timestamp)
+	});
+}
+/**
 * Creates a sink that forwards log records to OpenTelemetry.
+*
+* When a custom `loggerProvider` is provided, it is used directly.
+* Otherwise, the sink will lazily initialize a logger provider on the first
+* log record, using the protocol determined by environment variables.
+*
 * @param options Options for creating the sink.
 * @returns The sink.
 */
 function getOpenTelemetrySink(options = {}) {
 	if (options.diagnostics) __opentelemetry_api.diag.setLogger(new DiagLoggerAdaptor(), __opentelemetry_api.DiagLogLevel.DEBUG);
-	let loggerProvider;
-	if (options.loggerProvider == null) {
-		const resource = (0, __opentelemetry_resources.defaultResource)().merge((0, __opentelemetry_resources.resourceFromAttributes)({ [__opentelemetry_semantic_conventions.ATTR_SERVICE_NAME]: options.serviceName ?? getEnvironmentVariable("OTEL_SERVICE_NAME") }));
-		loggerProvider = new __opentelemetry_sdk_logs.LoggerProvider({ resource });
-		const otlpExporter = new __opentelemetry_exporter_logs_otlp_http.OTLPLogExporter(options.otlpExporterConfig);
-		loggerProvider.addLogRecordProcessor(new __opentelemetry_sdk_logs.SimpleLogRecordProcessor(otlpExporter));
-	} else loggerProvider = options.loggerProvider;
-	const objectRenderer = options.objectRenderer ?? "inspect";
-	const logger = loggerProvider.getLogger(require_deno.default.name, require_deno.default.version);
-	const sink = (record) => {
-		const { category, level, message, timestamp, properties } = record;
+	if (options.loggerProvider != null) {
+		const loggerProvider$1 = options.loggerProvider;
+		const logger$1 = loggerProvider$1.getLogger(require_deno.default.name, require_deno.default.version);
+		const shutdown = loggerProvider$1.shutdown?.bind(loggerProvider$1);
+		const sink$1 = Object.assign((record) => {
+			const { category } = record;
+			if (category[0] === "logtape" && category[1] === "meta" && category[2] === "otel") return;
+			emitLogRecord(logger$1, record, options);
+		}, { async [Symbol.asyncDispose]() {
+			if (shutdown != null) await shutdown();
+		} });
+		return sink$1;
+	}
+	let loggerProvider = null;
+	let logger = null;
+	let initPromise = null;
+	let initError = null;
+	const sink = Object.assign((record) => {
+		const { category } = record;
 		if (category[0] === "logtape" && category[1] === "meta" && category[2] === "otel") return;
-		const severityNumber = mapLevelToSeverityNumber(level);
-		const attributes = convertToAttributes(properties, objectRenderer);
-		attributes["category"] = [...category];
-		logger.emit({
-			severityNumber,
-			severityText: level,
-			body: typeof options.messageType === "function" ? convertMessageToCustomBodyFormat(message, objectRenderer, options.messageType) : options.messageType === "array" ? convertMessageToArray(message, objectRenderer) : convertMessageToString(message, objectRenderer),
-			attributes,
-			timestamp: new Date(timestamp)
+		if (logger != null) {
+			emitLogRecord(logger, record, options);
+			return;
+		}
+		if (initError != null) return;
+		if (initPromise == null) initPromise = initializeLoggerProvider(options).then((provider) => {
+			loggerProvider = provider;
+			logger = provider.getLogger(require_deno.default.name, require_deno.default.version);
+			emitLogRecord(logger, record, options);
+		}).catch((error) => {
+			initError = error;
+			console.error("Failed to initialize OpenTelemetry logger:", error);
 		});
-	};
-	if (loggerProvider.shutdown != null) {
-		const shutdown = loggerProvider.shutdown.bind(loggerProvider);
-		sink[Symbol.asyncDispose] = shutdown;
-	}
+	}, { async [Symbol.asyncDispose]() {
+		if (initPromise != null) try {
+			await initPromise;
+		} catch {
+			return;
+		}
+		if (loggerProvider?.shutdown != null) await loggerProvider.shutdown();
+	} });
 	return sink;
 }
 function mapLevelToSeverityNumber(level) {

package/dist/mod.d.cts

@@ -1,7 +1,6 @@
 import { Sink } from "@logtape/logtape";
 import { AnyValue, LoggerProvider } from "@opentelemetry/api-logs";
 import { OTLPExporterNodeConfigBase } from "@opentelemetry/otlp-exporter-base";
-import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
 
 //#region src/mod.d.ts
 
@@ -9,11 +8,6 @@ import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
  * The OpenTelemetry logger provider.
  */
 type ILoggerProvider = LoggerProvider & {
-  /**
-   * Adds a new {@link LogRecordProcessor} to this logger.
-   * @param processor the new LogRecordProcessor to be added.
-   */
-  addLogRecordProcessor(processor: LogRecordProcessor): void;
   /**
    * Flush all buffered data and shut down the LoggerProvider and all registered
    * LogRecordProcessor.
@@ -36,13 +30,14 @@ type Message = (string | null | undefined)[];
  */
 type BodyFormatter = (message: Message) => AnyValue;
 /**
- * Options for creating an OpenTelemetry sink.
+ * The OTLP protocol to use for exporting logs.
+ * @since 0.9.0
  */
-interface OpenTelemetrySinkOptions {
-  /**
-   * The OpenTelemetry logger provider to use.
-   */
-  loggerProvider?: ILoggerProvider;
+type OtlpProtocol = "grpc" | "http/protobuf" | "http/json";
+/**
+ * Base options shared by all OpenTelemetry sink configurations.
+ */
+interface OpenTelemetrySinkOptionsBase {
   /**
    * The way to render the message in the log record.  If `"string"`,
    * the message is rendered as a single string with the values are
@@ -66,24 +61,94 @@ interface OpenTelemetrySinkOptions {
    * Turned off by default.
    */
   diagnostics?: boolean;
+}
+/**
+ * Options for creating an OpenTelemetry sink with a custom logger provider.
+ * When using this configuration, you are responsible for setting up the
+ * logger provider with appropriate exporters and processors.
+ *
+ * This is the recommended approach for production use as it gives you
+ * full control over the OpenTelemetry configuration.
+ * @since 0.9.0
+ */
+interface OpenTelemetrySinkProviderOptions extends OpenTelemetrySinkOptionsBase {
+  /**
+   * The OpenTelemetry logger provider to use.
+   */
+  loggerProvider: ILoggerProvider;
+}
+/**
+ * Options for creating an OpenTelemetry sink with automatic exporter creation.
+ * The protocol is determined by environment variables:
+ * - `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` (highest priority)
+ * - `OTEL_EXPORTER_OTLP_PROTOCOL` (fallback)
+ * - Default: `"http/json"`
+ *
+ * For production use, consider providing your own {@link ILoggerProvider}
+ * via {@link OpenTelemetrySinkProviderOptions} for more control.
+ * @since 0.9.0
+ */
+interface OpenTelemetrySinkExporterOptions extends OpenTelemetrySinkOptionsBase {
+  /**
+   * The OpenTelemetry logger provider to use.
+   * Must be undefined or omitted when using exporter options.
+   */
+  loggerProvider?: undefined;
   /**
    * The OpenTelemetry OTLP exporter configuration to use.
-   * Ignored if `loggerProvider` is provided.
    */
   otlpExporterConfig?: OTLPExporterNodeConfigBase;
   /**
    * The service name to use.  If not provided, the service name is
    * taken from the `OTEL_SERVICE_NAME` environment variable.
-   * Ignored if `loggerProvider` is provided.
    */
   serviceName?: string;
 }
+/**
+ * Options for creating an OpenTelemetry sink.
+ *
+ * This is a union type that accepts either:
+ * - {@link OpenTelemetrySinkProviderOptions}: Provide your own `loggerProvider`
+ *   (recommended for production)
+ * - {@link OpenTelemetrySinkExporterOptions}: Let the sink create an exporter
+ *   automatically based on environment variables
+ *
+ * When no `loggerProvider` is provided, the protocol is determined by:
+ * 1. `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` environment variable
+ * 2. `OTEL_EXPORTER_OTLP_PROTOCOL` environment variable
+ * 3. Default: `"http/json"`
+ *
+ * @example Using a custom logger provider (recommended)
+ * ```typescript
+ * import { LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
+ * import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
+ *
+ * const provider = new LoggerProvider();
+ * provider.addLogRecordProcessor(new SimpleLogRecordProcessor(new OTLPLogExporter()));
+ *
+ * const sink = getOpenTelemetrySink({ loggerProvider: provider });
+ * ```
+ *
+ * @example Using automatic exporter creation
+ * ```typescript
+ * // Protocol determined by OTEL_EXPORTER_OTLP_PROTOCOL env var
+ * const sink = getOpenTelemetrySink({
+ *   serviceName: "my-service",
+ * });
+ * ```
+ */
+type OpenTelemetrySinkOptions = OpenTelemetrySinkProviderOptions | OpenTelemetrySinkExporterOptions;
 /**
  * Creates a sink that forwards log records to OpenTelemetry.
+ *
+ * When a custom `loggerProvider` is provided, it is used directly.
+ * Otherwise, the sink will lazily initialize a logger provider on the first
+ * log record, using the protocol determined by environment variables.
+ *
  * @param options Options for creating the sink.
  * @returns The sink.
  */
-declare function getOpenTelemetrySink(options?: OpenTelemetrySinkOptions): Sink;
+declare function getOpenTelemetrySink(options?: OpenTelemetrySinkOptions): Sink & AsyncDisposable;
 //#endregion
-export { BodyFormatter, ObjectRenderer, OpenTelemetrySinkOptions, getOpenTelemetrySink };
+export { BodyFormatter, ObjectRenderer, OpenTelemetrySinkExporterOptions, OpenTelemetrySinkOptions, OpenTelemetrySinkProviderOptions, OtlpProtocol, getOpenTelemetrySink };
 //# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAuBiC;KAyC5B,eAAA,GAAkB,cAAH,GAAA;EAAA;;;AAaM;EASd,qBAAc,CAAA,SAAA,EAjBS,kBAiBT,CAAA,EAAA,IAAA;EAErB;AAML;;;;AAA0D;EAKzC,QAAA,CAAA,EAAA,GAAA,GAtBE,OAsBF,CAAA,IAAwB,CAAA;CAAA;;;;;AAoCQ;AAejD;AAAoC,KAhExB,cAAA,GAgEwB,MAAA,GAAA,SAAA;KA9D/B,OAAA,GA+DM,CAAA,MAAA,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA;;AACJ;;;KA1DK,aAAA,aAA0B,YAAY;;;;UAKjC,wBAAA;;;;mBAIE;;;;;;;;;;qCAWkB;;;;;;;mBAQlB;;;;;;;;;;;uBAaI;;;;;;;;;;;;;iBAeP,oBAAA,WACL,2BACR"}
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAeoF;KAoJ/E,eAAA,GAAkB,cAAH,GAAA;EAAA;;AAOM;AAS1B;AAAgD;AAQhD;EAAyB,QAAA,CAAA,EAAA,GAAA,GAjBN,OAiBM,CAAA,IAAA,CAAA;CAAA;;AAAiC;AAM1D;AAAkE;;;AAuB/C,KArCP,cAAA,GAqCO,MAAA,GAAA,SAAA;AAAc,KAnC5B,OAAA,GAmC4B,CAAA,MAAA,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA;AAmBjC;;;;AACsC,KAjD1B,aAAA,GAiD0B,CAAA,OAAA,EAjDA,OAiDA,EAAA,GAjDY,QAiDZ;AAkBtC;;;;AACsC,KA9D1B,YAAA,GA8D0B,MAAA,GAAA,eAAA,GAAA,WAAA;AAoDtC;;;UA7GU,4BAAA,CA+GN;EAAgC;AA2FpC;;;;;AAEyB;;;qCAlMY;;;;;;;mBAQlB;;;;;;;;;;;;;;;;;UAmBF,gCAAA,SACP;;;;kBAIQ;;;;;;;;;;;;;UAcD,gCAAA,SACP;;;;;;;;;uBAUa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0CX,wBAAA,GACR,mCACA;;;;;;;;;;;iBA2FY,oBAAA,WACL,2BACR,OAAO"}

package/dist/mod.d.ts

@@ -1,6 +1,5 @@
 import { Sink } from "@logtape/logtape";
 import { AnyValue, LoggerProvider } from "@opentelemetry/api-logs";
-import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
 import { OTLPExporterNodeConfigBase } from "@opentelemetry/otlp-exporter-base";
 
 //#region src/mod.d.ts
@@ -9,11 +8,6 @@ import { OTLPExporterNodeConfigBase } from "@opentelemetry/otlp-exporter-base";
  * The OpenTelemetry logger provider.
  */
 type ILoggerProvider = LoggerProvider & {
-  /**
-   * Adds a new {@link LogRecordProcessor} to this logger.
-   * @param processor the new LogRecordProcessor to be added.
-   */
-  addLogRecordProcessor(processor: LogRecordProcessor): void;
   /**
    * Flush all buffered data and shut down the LoggerProvider and all registered
    * LogRecordProcessor.
@@ -36,13 +30,14 @@ type Message = (string | null | undefined)[];
  */
 type BodyFormatter = (message: Message) => AnyValue;
 /**
- * Options for creating an OpenTelemetry sink.
+ * The OTLP protocol to use for exporting logs.
+ * @since 0.9.0
  */
-interface OpenTelemetrySinkOptions {
-  /**
-   * The OpenTelemetry logger provider to use.
-   */
-  loggerProvider?: ILoggerProvider;
+type OtlpProtocol = "grpc" | "http/protobuf" | "http/json";
+/**
+ * Base options shared by all OpenTelemetry sink configurations.
+ */
+interface OpenTelemetrySinkOptionsBase {
   /**
    * The way to render the message in the log record.  If `"string"`,
    * the message is rendered as a single string with the values are
@@ -66,24 +61,94 @@ interface OpenTelemetrySinkOptions {
    * Turned off by default.
    */
   diagnostics?: boolean;
+}
+/**
+ * Options for creating an OpenTelemetry sink with a custom logger provider.
+ * When using this configuration, you are responsible for setting up the
+ * logger provider with appropriate exporters and processors.
+ *
+ * This is the recommended approach for production use as it gives you
+ * full control over the OpenTelemetry configuration.
+ * @since 0.9.0
+ */
+interface OpenTelemetrySinkProviderOptions extends OpenTelemetrySinkOptionsBase {
+  /**
+   * The OpenTelemetry logger provider to use.
+   */
+  loggerProvider: ILoggerProvider;
+}
+/**
+ * Options for creating an OpenTelemetry sink with automatic exporter creation.
+ * The protocol is determined by environment variables:
+ * - `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` (highest priority)
+ * - `OTEL_EXPORTER_OTLP_PROTOCOL` (fallback)
+ * - Default: `"http/json"`
+ *
+ * For production use, consider providing your own {@link ILoggerProvider}
+ * via {@link OpenTelemetrySinkProviderOptions} for more control.
+ * @since 0.9.0
+ */
+interface OpenTelemetrySinkExporterOptions extends OpenTelemetrySinkOptionsBase {
+  /**
+   * The OpenTelemetry logger provider to use.
+   * Must be undefined or omitted when using exporter options.
+   */
+  loggerProvider?: undefined;
   /**
    * The OpenTelemetry OTLP exporter configuration to use.
-   * Ignored if `loggerProvider` is provided.
    */
   otlpExporterConfig?: OTLPExporterNodeConfigBase;
   /**
    * The service name to use.  If not provided, the service name is
    * taken from the `OTEL_SERVICE_NAME` environment variable.
-   * Ignored if `loggerProvider` is provided.
    */
   serviceName?: string;
 }
+/**
+ * Options for creating an OpenTelemetry sink.
+ *
+ * This is a union type that accepts either:
+ * - {@link OpenTelemetrySinkProviderOptions}: Provide your own `loggerProvider`
+ *   (recommended for production)
+ * - {@link OpenTelemetrySinkExporterOptions}: Let the sink create an exporter
+ *   automatically based on environment variables
+ *
+ * When no `loggerProvider` is provided, the protocol is determined by:
+ * 1. `OTEL_EXPORTER_OTLP_LOGS_PROTOCOL` environment variable
+ * 2. `OTEL_EXPORTER_OTLP_PROTOCOL` environment variable
+ * 3. Default: `"http/json"`
+ *
+ * @example Using a custom logger provider (recommended)
+ * ```typescript
+ * import { LoggerProvider, SimpleLogRecordProcessor } from "@opentelemetry/sdk-logs";
+ * import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
+ *
+ * const provider = new LoggerProvider();
+ * provider.addLogRecordProcessor(new SimpleLogRecordProcessor(new OTLPLogExporter()));
+ *
+ * const sink = getOpenTelemetrySink({ loggerProvider: provider });
+ * ```
+ *
+ * @example Using automatic exporter creation
+ * ```typescript
+ * // Protocol determined by OTEL_EXPORTER_OTLP_PROTOCOL env var
+ * const sink = getOpenTelemetrySink({
+ *   serviceName: "my-service",
+ * });
+ * ```
+ */
+type OpenTelemetrySinkOptions = OpenTelemetrySinkProviderOptions | OpenTelemetrySinkExporterOptions;
 /**
  * Creates a sink that forwards log records to OpenTelemetry.
+ *
+ * When a custom `loggerProvider` is provided, it is used directly.
+ * Otherwise, the sink will lazily initialize a logger provider on the first
+ * log record, using the protocol determined by environment variables.
+ *
  * @param options Options for creating the sink.
  * @returns The sink.
  */
-declare function getOpenTelemetrySink(options?: OpenTelemetrySinkOptions): Sink;
+declare function getOpenTelemetrySink(options?: OpenTelemetrySinkOptions): Sink & AsyncDisposable;
 //#endregion
-export { BodyFormatter, ObjectRenderer, OpenTelemetrySinkOptions, getOpenTelemetrySink };
+export { BodyFormatter, ObjectRenderer, OpenTelemetrySinkExporterOptions, OpenTelemetrySinkOptions, OpenTelemetrySinkProviderOptions, OtlpProtocol, getOpenTelemetrySink };
 //# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;;;AAuBiC;KAyC5B,eAAA,GAAkB,cAAH,GAAA;EAAA;;;AAaM;EASd,qBAAc,CAAA,SAAA,EAjBS,kBAiBT,CAAA,EAAA,IAAA;EAErB;AAML;;;;AAA0D;EAKzC,QAAA,CAAA,EAAA,GAAA,GAtBE,OAsBF,CAAA,IAAwB,CAAA;CAAA;;;;;AAoCQ;AAejD;AAAoC,KAhExB,cAAA,GAgEwB,MAAA,GAAA,SAAA;KA9D/B,OAAA,GA+DM,CAAA,MAAA,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA;;AACJ;;;KA1DK,aAAA,aAA0B,YAAY;;;;UAKjC,wBAAA;;;;mBAIE;;;;;;;;;;qCAWkB;;;;;;;mBAQlB;;;;;;;;;;;uBAaI;;;;;;;;;;;;;iBAeP,oBAAA,WACL,2BACR"}
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAeoF;KAoJ/E,eAAA,GAAkB,cAAH,GAAA;EAAA;;AAOM;AAS1B;AAAgD;AAQhD;EAAyB,QAAA,CAAA,EAAA,GAAA,GAjBN,OAiBM,CAAA,IAAA,CAAA;CAAA;;AAAiC;AAM1D;AAAkE;;;AAuB/C,KArCP,cAAA,GAqCO,MAAA,GAAA,SAAA;AAAc,KAnC5B,OAAA,GAmC4B,CAAA,MAAA,GAAA,IAAA,GAAA,SAAA,CAAA,EAAA;AAmBjC;;;;AACsC,KAjD1B,aAAA,GAiD0B,CAAA,OAAA,EAjDA,OAiDA,EAAA,GAjDY,QAiDZ;AAkBtC;;;;AACsC,KA9D1B,YAAA,GA8D0B,MAAA,GAAA,eAAA,GAAA,WAAA;AAoDtC;;;UA7GU,4BAAA,CA+GN;EAAgC;AA2FpC;;;;;AAEyB;;;qCAlMY;;;;;;;mBAQlB;;;;;;;;;;;;;;;;;UAmBF,gCAAA,SACP;;;;kBAIQ;;;;;;;;;;;;;UAcD,gCAAA,SACP;;;;;;;;;uBAUa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0CX,wBAAA,GACR,mCACA;;;;;;;;;;;iBA2FY,oBAAA,WACL,2BACR,OAAO"}