@devopsplaybook.io/otel-utils 1.7.0 → 1.8.0

package/src/ModuleLogger.ts

@@ -1,14 +1,25 @@
 import { SeverityNumber } from "@opentelemetry/api";
 import type { Span } from "@opentelemetry/api";
+import type { ConsoleLogMode } from "./models/ConfigOTelInterface";
 import { StandardLoggerInterface } from "./models/StandardLoggerInterface";
 
+export interface ModuleLoggerOptions {
+  consoleMode?: ConsoleLogMode;
+}
+
 export class ModuleLogger {
   private module: string;
   private standardLogger: StandardLoggerInterface;
+  private consoleMode: ConsoleLogMode;
 
-  constructor(module: string, standardLogger: StandardLoggerInterface) {
+  constructor(
+    module: string,
+    standardLogger: StandardLoggerInterface,
+    options: ModuleLoggerOptions = {},
+  ) {
     this.module = module;
     this.standardLogger = standardLogger;
+    this.consoleMode = options.consoleMode ?? "always";
   }
 
   public info(message: string, context?: Span): void {
@@ -19,8 +30,18 @@ export class ModuleLogger {
     this.display("warn", message, SeverityNumber.WARN, null, context);
   }
 
-  public error(message: string, error?: Error, context?: Span): void {
-    this.display("error", message, SeverityNumber.ERROR, error, context);
+  public error(message: string, error?: unknown, context?: Span): void {
+    if (!context && isSpanLike(error)) {
+      context = error;
+      error = undefined;
+    }
+    this.display(
+      "error",
+      message,
+      SeverityNumber.ERROR,
+      normalizeError(error),
+      context,
+    );
   }
 
   private display(
@@ -30,13 +51,17 @@ export class ModuleLogger {
     error?: Error | null,
     context?: Span,
   ): void {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const attributes: Record<string, any> = { "log.type": "custom" };
+    const attributes: Record<string, string> = {
+      "log.type": "custom",
+      "log.module": this.module,
+    };
 
     if (error) {
       attributes["exception.type"] = error.name;
       attributes["exception.message"] = error.message;
-      attributes["exception.stacktrace"] = error.stack;
+      if (error.stack !== undefined) {
+        attributes["exception.stacktrace"] = error.stack;
+      }
     }
 
     if (context) {
@@ -45,8 +70,13 @@ export class ModuleLogger {
       attributes["trace.id"] = spanCtx.traceId;
     }
 
-    console.log(`[${level}] [${this.module}] ${message}`);
     const logger = this.standardLogger.getLogger();
+    const mirrorToConsole =
+      this.consoleMode === "always" ||
+      (this.consoleMode === "fallback" && !logger);
+    if (mirrorToConsole) {
+      writeToConsole(level, `[${level}] [${this.module}] ${message}`);
+    }
     if (!logger) {
       return;
     }
@@ -58,3 +88,50 @@ export class ModuleLogger {
     });
   }
 }
+
+function normalizeError(value: unknown): Error | null {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  if (value instanceof Error) {
+    return value;
+  }
+  return new Error(serializeUnknown(value));
+}
+
+function serializeUnknown(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    const json = JSON.stringify(value);
+    if (json !== undefined) {
+      return json;
+    }
+  } catch {
+    // Not serialisable; fall back to String below.
+  }
+  try {
+    return String(value);
+  } catch {
+    return "Unknown error";
+  }
+}
+
+function isSpanLike(value: unknown): value is Span {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    typeof (value as { spanContext?: unknown }).spanContext === "function"
+  );
+}
+
+function writeToConsole(level: string, line: string): void {
+  if (level === "error") {
+    console.error(line);
+  } else if (level === "warn") {
+    console.warn(line);
+  } else {
+    console.log(line);
+  }
+}

package/src/StandardLogger.spec.ts

@@ -1,9 +1,40 @@
 import { logs, SeverityNumber } from "@opentelemetry/api";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { LoggerProvider } from "@opentelemetry/sdk-logs";
+import type { ConsoleLogMode } from "./models/ConfigOTelInterface";
 import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
 import { StandardLogger } from "./StandardLogger";
 
+jest.mock("@opentelemetry/sdk-logs", () => {
+  const actual =
+    jest.requireActual<typeof import("@opentelemetry/sdk-logs")>(
+      "@opentelemetry/sdk-logs",
+    );
+  const batchProcessorOptions: unknown[] = [];
+  class RecordingBatchLogRecordProcessor extends actual.BatchLogRecordProcessor {
+    constructor(
+      options: ConstructorParameters<typeof actual.BatchLogRecordProcessor>[0],
+    ) {
+      super(options);
+      batchProcessorOptions.push(options);
+    }
+  }
+  return {
+    ...actual,
+    BatchLogRecordProcessor: RecordingBatchLogRecordProcessor,
+    __batchProcessorOptions: batchProcessorOptions,
+  };
+});
+
+interface SdkLogsMock {
+  __batchProcessorOptions: unknown[];
+}
+
+function batchProcessorOptions(): unknown[] {
+  return (jest.requireMock("@opentelemetry/sdk-logs") as SdkLogsMock)
+    .__batchProcessorOptions;
+}
+
 jest.mock("@opentelemetry/exporter-logs-otlp-http", () => {
   const { ExportResultCode } = jest.requireActual<
     typeof import("@opentelemetry/core")
@@ -68,6 +99,7 @@ describe("StandardLogger", () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    batchProcessorOptions().length = 0;
     logs.disable();
     warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
     logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
@@ -233,4 +265,215 @@ describe("StandardLogger", () => {
       logs.getLogger("external-lib").emit({ body: "dropped" }),
     ).not.toThrow();
   });
+
+  describe("batch processor tunables", () => {
+    it("passes the documented defaults to BatchLogRecordProcessor", async () => {
+      const logger = makeLogger();
+      await logger.initOTel(collectorConfig("http://collector/v1/logs"));
+
+      expect(batchProcessorOptions()).toHaveLength(1);
+      expect(batchProcessorOptions()[0]).toEqual({
+        exporter: expect.anything(),
+        maxQueueSize: 2048,
+        maxExportBatchSize: 512,
+        exportTimeoutMillis: 30000,
+        scheduledDelayMillis: 60000,
+      });
+      await logger.shutdown();
+    });
+
+    it("passes configured batch values to BatchLogRecordProcessor", async () => {
+      const logger = makeLogger();
+      await logger.initOTel({
+        ...collectorConfig("http://collector/v1/logs"),
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: 5,
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE: 4096,
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE: 1024,
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS: 15000,
+      });
+
+      expect(batchProcessorOptions()[0]).toEqual({
+        exporter: expect.anything(),
+        maxQueueSize: 4096,
+        maxExportBatchSize: 1024,
+        exportTimeoutMillis: 15000,
+        scheduledDelayMillis: 5000,
+      });
+      await logger.shutdown();
+    });
+
+    it("falls back to the documented defaults for invalid batch values", async () => {
+      const logger = makeLogger();
+      await logger.initOTel({
+        ...collectorConfig("http://collector/v1/logs"),
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE: 0,
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE: -1,
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS: 1.5,
+      });
+
+      expect(batchProcessorOptions()[0]).toEqual({
+        exporter: expect.anything(),
+        maxQueueSize: 2048,
+        maxExportBatchSize: 512,
+        exportTimeoutMillis: 30000,
+        scheduledDelayMillis: 60000,
+      });
+      await logger.shutdown();
+    });
+
+    it.each([0, -5, 0.5])(
+      "clamps the log export interval of %p seconds to one second",
+      async (interval) => {
+        const logger = makeLogger();
+        await logger.initOTel({
+          ...collectorConfig("http://collector/v1/logs"),
+          OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: interval,
+        });
+
+        expect(
+          (batchProcessorOptions()[0] as { scheduledDelayMillis: number })
+            .scheduledDelayMillis,
+        ).toBe(1000);
+        await logger.shutdown();
+      },
+    );
+
+    it("falls back to the default delay for a NaN interval", async () => {
+      const logger = makeLogger();
+      await logger.initOTel({
+        ...collectorConfig("http://collector/v1/logs"),
+        OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: NaN,
+      });
+
+      expect(
+        (batchProcessorOptions()[0] as { scheduledDelayMillis: number })
+          .scheduledDelayMillis,
+      ).toBe(60000);
+      await logger.shutdown();
+    });
+  });
+
+  describe("service identity validation", () => {
+    it("rejects an empty SERVICE_ID without creating an exporter", async () => {
+      const logger = makeLogger();
+
+      await expect(
+        logger.initOTel({
+          SERVICE_ID: "   ",
+          VERSION: "1.0.0",
+          OPENTELEMETRY_COLLECTOR_HTTP_LOGS: "http://collector/v1/logs",
+        }),
+      ).rejects.toThrow("[otel-utils] SERVICE_ID must be a non-empty string");
+
+      expect(mockExporterConstructor).not.toHaveBeenCalled();
+      expect(logger.getLogger()).toBeUndefined();
+      await expect(logger.shutdown()).resolves.toBeUndefined();
+    });
+
+    it("rejects an empty VERSION without creating an exporter", async () => {
+      const logger = makeLogger();
+
+      await expect(
+        logger.initOTel({
+          SERVICE_ID: "log-service",
+          VERSION: "",
+          OPENTELEMETRY_COLLECTOR_HTTP_LOGS: "http://collector/v1/logs",
+        }),
+      ).rejects.toThrow("[otel-utils] VERSION must be a non-empty string");
+
+      expect(mockExporterConstructor).not.toHaveBeenCalled();
+      await expect(logger.shutdown()).resolves.toBeUndefined();
+    });
+
+    it("keeps the previous provider when a re-initialisation is invalid", async () => {
+      const logger = makeLogger();
+      await logger.initOTel(collectorConfig("http://collector-1/v1/logs"));
+      logger.createModuleLogger("billing").info("before-invalid-reinit");
+
+      await expect(
+        logger.initOTel({
+          SERVICE_ID: "",
+          VERSION: "1.0.0",
+          OPENTELEMETRY_COLLECTOR_HTTP_LOGS: "http://collector-2/v1/logs",
+        }),
+      ).rejects.toThrow("[otel-utils] SERVICE_ID must be a non-empty string");
+
+      expect(logger.getLogger()).toBeDefined();
+      expect(logs.getLoggerProvider()).toBeInstanceOf(LoggerProvider);
+      logger.createModuleLogger("billing").info("after-invalid-reinit");
+      await logger.shutdown();
+
+      expect(mockExporterConstructor).toHaveBeenCalledTimes(1);
+      expect(exportedBodies(exporterAt(0))).toEqual(
+        expect.arrayContaining([
+          "[billing] before-invalid-reinit",
+          "[billing] after-invalid-reinit",
+        ]),
+      );
+    });
+  });
+
+  describe("console log modes", () => {
+    it("mirrors through console.log by default", async () => {
+      const logger = makeLogger();
+      await logger.initOTel(collectorConfig("http://collector/v1/logs"));
+
+      logger.createModuleLogger("billing").info("mirrored");
+
+      expect(logSpy).toHaveBeenCalledWith("[info] [billing] mirrored");
+      await logger.shutdown();
+    });
+
+    it("never suppresses console output while records are still exported", async () => {
+      const logger = makeLogger();
+      await logger.initOTel({
+        ...collectorConfig("http://collector/v1/logs"),
+        OPENTELEMETRY_CONSOLE_LOG_MODE: "never",
+      });
+
+      logger.createModuleLogger("billing").info("silent");
+
+      expect(logSpy).not.toHaveBeenCalled();
+      await logger.shutdown();
+      expect(exportedBodies(exporterAt(0))).toContain("[billing] silent");
+    });
+
+    it("warns once and behaves as always for an invalid mode", async () => {
+      const logger = makeLogger();
+      await logger.initOTel({
+        ...collectorConfig("http://collector/v1/logs"),
+        OPENTELEMETRY_CONSOLE_LOG_MODE:
+          "sometimes" as unknown as ConsoleLogMode,
+      });
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("OPENTELEMETRY_CONSOLE_LOG_MODE"),
+      );
+      logger.createModuleLogger("billing").info("still mirrored");
+      expect(logSpy).toHaveBeenCalledWith("[info] [billing] still mirrored");
+      await logger.shutdown();
+    });
+
+    it("fallback mirrors only when no logs endpoint is configured", async () => {
+      const withEndpoint = makeLogger();
+      await withEndpoint.initOTel({
+        ...collectorConfig("http://collector/v1/logs"),
+        OPENTELEMETRY_CONSOLE_LOG_MODE: "fallback",
+      });
+      withEndpoint.createModuleLogger("billing").info("not-mirrored");
+      expect(logSpy).not.toHaveBeenCalled();
+      await withEndpoint.shutdown();
+      expect(exportedBodies(exporterAt(0))).toContain("[billing] not-mirrored");
+
+      const withoutEndpoint = makeLogger();
+      await withoutEndpoint.initOTel({
+        SERVICE_ID: "log-service",
+        VERSION: "1.0.0",
+        OPENTELEMETRY_CONSOLE_LOG_MODE: "fallback",
+      });
+      withoutEndpoint.createModuleLogger("billing").warn("mirrored-fallback");
+      expect(warnSpy).toHaveBeenCalledWith("[warn] [billing] mirrored-fallback");
+      await withoutEndpoint.shutdown();
+    });
+  });
 });

package/src/StandardLogger.ts

@@ -4,8 +4,17 @@ import {
   BatchLogRecordProcessor,
   LoggerProvider,
 } from "@opentelemetry/sdk-logs";
-import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+import type {
+  ConfigOTelInterface,
+  ConsoleLogMode,
+} from "./models/ConfigOTelInterface";
 import { createOTelResource } from "./utils/createResource";
+import {
+  normalizeConsoleLogMode,
+  normalizeExportIntervalSeconds,
+  normalizePositiveInteger,
+  validateServiceIdentity,
+} from "./utils/configValidation";
 import { ModuleLogger } from "./ModuleLogger";
 
 import type { StandardLoggerInterface } from "./models/StandardLoggerInterface";
@@ -22,8 +31,15 @@ export class StandardLogger implements StandardLoggerInterface {
   private serviceName?: string;
   private ownsGlobalProvider = false;
   private shutdownPromise?: Promise<void>;
+  private consoleMode: ConsoleLogMode = "always";
 
   public async initOTel(config: ConfigOTelInterface): Promise<void> {
+    // Validate before releasing the previous provider: a bad re-init must keep
+    // the working provider in place.
+    validateServiceIdentity(config);
+    this.consoleMode = normalizeConsoleLogMode(
+      config.OPENTELEMETRY_CONSOLE_LOG_MODE,
+    );
     // Re-initialisation flushes and unregisters the previous provider first.
     if (this.loggerProvider) {
       await this.releaseProvider();
@@ -50,10 +66,23 @@ export class StandardLogger implements StandardLoggerInterface {
       processors: [
         new BatchLogRecordProcessor({
           exporter,
-          maxQueueSize: 2048,
+          maxQueueSize: normalizePositiveInteger(
+            config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE,
+            2048,
+          ),
+          maxExportBatchSize: normalizePositiveInteger(
+            config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE,
+            512,
+          ),
+          exportTimeoutMillis: normalizePositiveInteger(
+            config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS,
+            30000,
+          ),
           scheduledDelayMillis:
-            (config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS ??
-              60) * 1000,
+            normalizeExportIntervalSeconds(
+              config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS,
+              60,
+            ) * 1000,
         }),
       ],
       resource: createOTelResource(this.serviceName, this.serviceVersion),
@@ -77,7 +106,7 @@ export class StandardLogger implements StandardLoggerInterface {
   }
 
   public createModuleLogger(moduleName: string): ModuleLogger {
-    return new ModuleLogger(moduleName, this);
+    return new ModuleLogger(moduleName, this, { consoleMode: this.consoleMode });
   }
 
   private registerGlobalProvider(): void {

package/src/StandardMeter.spec.ts

@@ -9,6 +9,38 @@ import {
 import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
 import { StandardMeter } from "./StandardMeter";
 
+jest.mock("@opentelemetry/sdk-metrics", () => {
+  const actual =
+    jest.requireActual<typeof import("@opentelemetry/sdk-metrics")>(
+      "@opentelemetry/sdk-metrics",
+    );
+  const metricReaderOptions: unknown[] = [];
+  class RecordingPeriodicExportingMetricReader extends actual.PeriodicExportingMetricReader {
+    constructor(
+      options: ConstructorParameters<
+        typeof actual.PeriodicExportingMetricReader
+      >[0],
+    ) {
+      super(options);
+      metricReaderOptions.push(options);
+    }
+  }
+  return {
+    ...actual,
+    PeriodicExportingMetricReader: RecordingPeriodicExportingMetricReader,
+    __metricReaderOptions: metricReaderOptions,
+  };
+});
+
+interface SdkMetricsMock {
+  __metricReaderOptions: unknown[];
+}
+
+function metricReaderOptions(): unknown[] {
+  return (jest.requireMock("@opentelemetry/sdk-metrics") as SdkMetricsMock)
+    .__metricReaderOptions;
+}
+
 jest.mock("@opentelemetry/exporter-metrics-otlp-http", () => {
   const {
     AggregationTemporality,
@@ -80,6 +112,7 @@ describe("StandardMeter", () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    metricReaderOptions().length = 0;
     metrics.disable();
     warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
   });
@@ -338,4 +371,76 @@ describe("StandardMeter", () => {
     expect(metricNames(exporterAt(1))).toContain("after-reinit");
     expect(shutdownSpy).toHaveBeenCalledTimes(1);
   });
+
+  describe("export interval tuning", () => {
+    it("uses the documented default interval", async () => {
+      const meter = makeMeter(
+        meterConfig("metric-service", "http://collector:4318/v1/metrics"),
+      );
+
+      expect(metricReaderOptions()).toHaveLength(1);
+      expect(metricReaderOptions()[0]).toEqual({
+        exporter: expect.anything(),
+        exportIntervalMillis: 60000,
+      });
+      await meter.shutdown();
+    });
+
+    it.each([0, -5, 0.5])(
+      "clamps the export interval of %p seconds to one second",
+      async (interval) => {
+        const meter = makeMeter({
+          ...meterConfig("metric-service", "http://collector:4318/v1/metrics"),
+          OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS: interval,
+        });
+
+        expect(
+          (metricReaderOptions()[0] as { exportIntervalMillis: number })
+            .exportIntervalMillis,
+        ).toBe(1000);
+        await meter.shutdown();
+      },
+    );
+
+    it("falls back to the default interval for a NaN value", async () => {
+      const meter = makeMeter({
+        ...meterConfig("metric-service", "http://collector:4318/v1/metrics"),
+        OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS: NaN,
+      });
+
+      expect(
+        (metricReaderOptions()[0] as { exportIntervalMillis: number })
+          .exportIntervalMillis,
+      ).toBe(60000);
+      await meter.shutdown();
+    });
+  });
+
+  describe("service identity validation", () => {
+    it("rejects an empty SERVICE_ID without creating an exporter", () => {
+      expect(
+        () =>
+          new StandardMeter({
+            SERVICE_ID: "   ",
+            VERSION: "1.0.0",
+            OPENTELEMETRY_COLLECTOR_HTTP_METRICS:
+              "http://collector:4318/v1/metrics",
+          }),
+      ).toThrow("[otel-utils] SERVICE_ID must be a non-empty string");
+      expect(mockExporterConstructor).not.toHaveBeenCalled();
+    });
+
+    it("rejects an empty VERSION without creating an exporter", () => {
+      expect(
+        () =>
+          new StandardMeter({
+            SERVICE_ID: "metric-service",
+            VERSION: "",
+            OPENTELEMETRY_COLLECTOR_HTTP_METRICS:
+              "http://collector:4318/v1/metrics",
+          }),
+      ).toThrow("[otel-utils] VERSION must be a non-empty string");
+      expect(mockExporterConstructor).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/StandardMeter.ts

@@ -14,6 +14,10 @@ import {
   PeriodicExportingMetricReader,
 } from "@opentelemetry/sdk-metrics";
 import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+import {
+  normalizeExportIntervalSeconds,
+  validateServiceIdentity,
+} from "./utils/configValidation";
 
 let globalMeterProvider: MeterProvider | undefined;
 
@@ -43,6 +47,7 @@ export class StandardMeter {
   private shutdownPromise?: Promise<void>;
 
   constructor(config: ConfigOTelInterface) {
+    validateServiceIdentity(config);
     this.serviceName = config.SERVICE_ID;
     this.serviceVersion = config.VERSION;
     let hasCollector = false;
@@ -64,8 +69,10 @@ export class StandardMeter {
           new PeriodicExportingMetricReader({
             exporter: metricExporter,
             exportIntervalMillis:
-              (config.OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS ??
-                60) * 1000,
+              normalizeExportIntervalSeconds(
+                config.OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS,
+                60,
+              ) * 1000,
           }),
         ],
       });

package/src/StandardTracer.spec.ts

@@ -225,6 +225,20 @@ describe("StandardTracer", () => {
     });
   });
 
+  describe("service identity validation", () => {
+    it("rejects an empty SERVICE_ID", () => {
+      expect(
+        () => new StandardTracer({ SERVICE_ID: "   ", VERSION: "1.0.0" }),
+      ).toThrow("[otel-utils] SERVICE_ID must be a non-empty string");
+    });
+
+    it("rejects an empty VERSION", () => {
+      expect(
+        () => new StandardTracer({ SERVICE_ID: "test-service", VERSION: "" }),
+      ).toThrow("[otel-utils] VERSION must be a non-empty string");
+    });
+  });
+
   describe("provider ownership and global registration", () => {
     it("routes each instance to its own exporter and resource", async () => {
       const first = makeTracer(

package/src/StandardTracer.ts

@@ -21,6 +21,7 @@ import {
   ATTR_HTTP_ROUTE,
 } from "@opentelemetry/semantic-conventions";
 import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+import { validateServiceIdentity } from "./utils/configValidation";
 import { createOTelResource } from "./utils/createResource";
 
 let globalTracerProvider: TracerProvider | undefined;
@@ -64,6 +65,7 @@ export class StandardTracer {
   private shutdownPromise?: Promise<void>;
 
   constructor(config: ConfigOTelInterface) {
+    validateServiceIdentity(config);
     this.serviceName = config.SERVICE_ID;
     this.serviceVersion = config.VERSION;
     const spanProcessors = [];

package/src/models/ConfigOTelInterface.ts

@@ -1,3 +1,5 @@
+export type ConsoleLogMode = "always" | "fallback" | "never";
+
 export interface ConfigOTelInterface {
   SERVICE_ID: string;
   VERSION: string;
@@ -6,5 +8,9 @@ export interface ConfigOTelInterface {
   OPENTELEMETRY_COLLECTOR_HTTP_LOGS?: string;
   OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS?: number;
   OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS?: number;
+  OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_QUEUE_SIZE?: number;
+  OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_MAX_BATCH_SIZE?: number;
+  OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_TIMEOUT_MILLIS?: number;
+  OPENTELEMETRY_CONSOLE_LOG_MODE?: ConsoleLogMode;
   OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER?: string;
 }