@devopsplaybook.io/otel-utils 1.2.0 → 1.3.0-beta.28.b481842

package/README.md

@@ -50,6 +50,8 @@ span.end();
 
 - `startSpan(name, parentSpan?)` — Creates a span. When no `parentSpan` is provided, adds `http.request_method=BACKEND` and `http.route` attributes. Span names are sanitized to `[a-zA-Z0-9-_/]`.
 - `static updateHttpHeader(context, headers?)` — Injects W3C trace context into an HTTP headers object for propagation to downstream services.
+- `forceFlush()` — Flushes pending spans to the exporter.
+- `shutdown()` — Shuts down the tracer provider and flushes pending spans (call once, on process exit).
 
 ### StandardLogger
 
@@ -70,6 +72,8 @@ moduleLog.info("Hello world");
 - `initOTel(config)` — Initializes the logger provider and optional OTLP exporter.
 - `getLogger()` — Returns the underlying OTel `Logger` or `undefined`.
 - `createModuleLogger(moduleName)` — Creates a `ModuleLogger` scoped to a module name.
+- `forceFlush()` — Flushes pending log records to the exporter (no-op when the provider was never initialized).
+- `shutdown()` — Shuts down the logger provider and flushes pending log records; no-op when the provider was never initialized (call once, on process exit).
 
 ### ModuleLogger
 
@@ -122,6 +126,8 @@ const cpuGauge = meter.createObservableGauge(
 - `createUpDownCounter(key)` — Creates an `UpDownCounter`.
 - `createHistogram(key)` — Creates a `Histogram`.
 - `createObservableGauge(key, callback, description?)` — Creates an `ObservableGauge` with a callback. Description is optional.
+- `forceFlush()` — Flushes pending metric data points to the exporter.
+- `shutdown()` — Shuts down the meter provider and flushes pending metric data points (call once, on process exit).
 
 ## Internal Utilities
 

package/dist/src/StandardLogger.d.ts

@@ -4,9 +4,12 @@ import { ModuleLogger } from "./ModuleLogger";
 import type { StandardLoggerInterface } from "./models/StandardLoggerInterface";
 export declare class StandardLogger implements StandardLoggerInterface {
     private logger?;
+    private loggerProvider?;
     private serviceVersion?;
     private serviceName?;
     initOTel(config: ConfigOTelInterface): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
     getLogger(): OTelLogger | undefined;
     createModuleLogger(moduleName: string): ModuleLogger;
 }

package/dist/src/StandardLogger.js

@@ -30,9 +30,20 @@ class StandardLogger {
                 ],
                 resource: (0, createResource_1.createOTelResource)(this.serviceName, this.serviceVersion),
             });
+            this.loggerProvider = loggerProvider;
             this.logger = loggerProvider.getLogger(`${this.serviceName}:${this.serviceVersion}`);
         }
     }
+    forceFlush() {
+        return this.loggerProvider
+            ? this.loggerProvider.forceFlush()
+            : Promise.resolve();
+    }
+    shutdown() {
+        return this.loggerProvider
+            ? this.loggerProvider.shutdown()
+            : Promise.resolve();
+    }
     getLogger() {
         return this.logger;
     }

package/dist/src/StandardMeter.d.ts

@@ -2,9 +2,12 @@ import { Counter, Histogram, ObservableGauge, UpDownCounter } from "@opentelemet
 import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
 export declare class StandardMeter {
     private meter;
+    private meterProvider;
     private serviceVersion;
     private serviceName;
     constructor(config: ConfigOTelInterface);
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
     createCounter(key: string): Counter;
     createUpDownCounter(key: string): UpDownCounter;
     createHistogram(key: string): Histogram;

package/dist/src/StandardMeter.js

@@ -36,8 +36,15 @@ class StandardMeter {
                 resource: (0, createResource_1.createOTelResource)(this.serviceName, this.serviceVersion),
             });
         }
+        this.meterProvider = meterProvider;
         this.meter = meterProvider.getMeter(`${this.serviceName}:${this.serviceVersion}`);
     }
+    forceFlush() {
+        return this.meterProvider.forceFlush();
+    }
+    shutdown() {
+        return this.meterProvider.shutdown();
+    }
     createCounter(key) {
         return this.meter.createCounter(`${this.serviceName}.${key}`);
     }

package/dist/src/StandardTracer.d.ts

@@ -4,9 +4,12 @@ export declare class StandardTracer {
     private static readonly SPAN_NAME_SANITIZE_RE;
     private static readonly PROPAGATOR;
     private tracer;
+    private traceProvider;
     private serviceVersion;
     private serviceName;
     constructor(config: ConfigOTelInterface);
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
     startSpan(name: string, parentSpan?: Span): Span;
     static updateHttpHeader(context: Span, headers?: {}): any;
 }

package/dist/src/StandardTracer.js

@@ -66,11 +66,18 @@ class StandardTracer {
             spanProcessors,
         });
         traceProvider.register();
+        this.traceProvider = traceProvider;
         const contextManager = new context_async_hooks_1.AsyncHooksContextManager();
         contextManager.enable();
         api_1.default.context.setGlobalContextManager(contextManager);
         this.tracer = api_1.default.trace.getTracer(`${this.serviceName}:${this.serviceVersion}`);
     }
+    forceFlush() {
+        return this.traceProvider.forceFlush();
+    }
+    shutdown() {
+        return this.traceProvider.shutdown();
+    }
     startSpan(name, parentSpan) {
         const sanitizedName = String(name).replace(StandardTracer.SPAN_NAME_SANITIZE_RE, "_");
         if (parentSpan) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devopsplaybook.io/otel-utils",
-  "version": "1.2.0",
+  "version": "1.3.0-beta.28.b481842",
   "description": "Utility to simplify integration with Open Telemetry",
   "keywords": [
     "Open",

package/src/Shutdown.spec.ts

@@ -0,0 +1,43 @@
+import { StandardLogger } from "./StandardLogger";
+import { StandardMeter } from "./StandardMeter";
+import { StandardTracer } from "./StandardTracer";
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+
+const config: ConfigOTelInterface = {
+  SERVICE_ID: "test-service",
+  VERSION: "1.0.0",
+  OPENTELEMETRY_COLLECTOR_HTTP_TRACES: "",
+  OPENTELEMETRY_COLLECTOR_HTTP_METRICS: "",
+  OPENTELEMETRY_COLLECTOR_HTTP_LOGS: "",
+  OPENTELEMETRY_COLLECTOR_AWS: false,
+  OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: 60,
+  OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS: 60,
+  OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER: "",
+};
+
+describe("OTel shutdown and forceFlush", () => {
+  it("StandardMeter exposes forceFlush and shutdown that resolve", async () => {
+    const meter = new StandardMeter(config);
+    await expect(meter.forceFlush()).resolves.toBeUndefined();
+    await expect(meter.shutdown()).resolves.toBeUndefined();
+  });
+
+  it("StandardLogger exposes forceFlush and shutdown that resolve without OTel endpoint", async () => {
+    const logger = new StandardLogger();
+    await expect(logger.forceFlush()).resolves.toBeUndefined();
+    await expect(logger.shutdown()).resolves.toBeUndefined();
+  });
+
+  it("StandardLogger flushes and shuts down the provider when initialized", async () => {
+    const logger = new StandardLogger();
+    logger.initOTel(config);
+    await expect(logger.forceFlush()).resolves.toBeUndefined();
+    await expect(logger.shutdown()).resolves.toBeUndefined();
+  });
+
+  it("StandardTracer exposes forceFlush and shutdown that resolve", async () => {
+    const tracer = new StandardTracer(config);
+    await expect(tracer.forceFlush()).resolves.toBeUndefined();
+    await expect(tracer.shutdown()).resolves.toBeUndefined();
+  });
+});

package/src/StandardLogger.ts

@@ -12,6 +12,7 @@ import type { StandardLoggerInterface } from "./models/StandardLoggerInterface";
 
 export class StandardLogger implements StandardLoggerInterface {
   private logger?: OTelLogger;
+  private loggerProvider?: LoggerProvider;
   private serviceVersion?: string;
   private serviceName?: string;
 
@@ -43,12 +44,25 @@ export class StandardLogger implements StandardLoggerInterface {
         resource: createOTelResource(this.serviceName, this.serviceVersion),
       });
 
+      this.loggerProvider = loggerProvider;
       this.logger = loggerProvider.getLogger(
         `${this.serviceName}:${this.serviceVersion}`,
       );
     }
   }
 
+  public forceFlush(): Promise<void> {
+    return this.loggerProvider
+      ? this.loggerProvider.forceFlush()
+      : Promise.resolve();
+  }
+
+  public shutdown(): Promise<void> {
+    return this.loggerProvider
+      ? this.loggerProvider.shutdown()
+      : Promise.resolve();
+  }
+
   public getLogger(): OTelLogger | undefined {
     return this.logger;
   }

package/src/StandardMeter.ts

@@ -15,6 +15,7 @@ import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
 
 export class StandardMeter {
   private meter: Meter;
+  private meterProvider: MeterProvider;
   private serviceVersion: string;
   private serviceName: string;
 
@@ -49,11 +50,20 @@ export class StandardMeter {
         resource: createOTelResource(this.serviceName, this.serviceVersion),
       });
     }
+    this.meterProvider = meterProvider;
     this.meter = meterProvider.getMeter(
       `${this.serviceName}:${this.serviceVersion}`,
     );
   }
 
+  public forceFlush(): Promise<void> {
+    return this.meterProvider.forceFlush();
+  }
+
+  public shutdown(): Promise<void> {
+    return this.meterProvider.shutdown();
+  }
+
   public createCounter(key: string): Counter {
     return this.meter.createCounter(`${this.serviceName}.${key}`);
   }

package/src/StandardTracer.ts

@@ -22,6 +22,7 @@ export class StandardTracer {
   private static readonly PROPAGATOR = new W3CTraceContextPropagator();
 
   private tracer: Tracer;
+  private traceProvider: NodeTracerProvider;
   private serviceVersion: string;
   private serviceName: string;
 
@@ -48,6 +49,7 @@ export class StandardTracer {
       spanProcessors,
     });
     traceProvider.register();
+    this.traceProvider = traceProvider;
     const contextManager = new AsyncHooksContextManager();
     contextManager.enable();
     opentelemetry.context.setGlobalContextManager(contextManager);
@@ -56,6 +58,14 @@ export class StandardTracer {
     );
   }
 
+  public forceFlush(): Promise<void> {
+    return this.traceProvider.forceFlush();
+  }
+
+  public shutdown(): Promise<void> {
+    return this.traceProvider.shutdown();
+  }
+
   public startSpan(name: string, parentSpan?: Span): Span {
     const sanitizedName = String(name).replace(
       StandardTracer.SPAN_NAME_SANITIZE_RE,