@devopsplaybook.io/otel-utils 1.8.0 → 1.9.0-beta.40.3ebb823

package/src/ModuleLogger.ts

@@ -1,137 +0,0 @@
-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,
-    options: ModuleLoggerOptions = {},
-  ) {
-    this.module = module;
-    this.standardLogger = standardLogger;
-    this.consoleMode = options.consoleMode ?? "always";
-  }
-
-  public info(message: string, context?: Span): void {
-    this.display("info", message, SeverityNumber.INFO, null, context);
-  }
-
-  public warn(message: string, context?: Span): void {
-    this.display("warn", message, SeverityNumber.WARN, null, 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(
-    level: string,
-    message: string,
-    severityNumber = SeverityNumber.INFO,
-    error?: Error | null,
-    context?: Span,
-  ): void {
-    const attributes: Record<string, string> = {
-      "log.type": "custom",
-      "log.module": this.module,
-    };
-
-    if (error) {
-      attributes["exception.type"] = error.name;
-      attributes["exception.message"] = error.message;
-      if (error.stack !== undefined) {
-        attributes["exception.stacktrace"] = error.stack;
-      }
-    }
-
-    if (context) {
-      const spanCtx = context.spanContext();
-      attributes["span.id"] = spanCtx.spanId;
-      attributes["trace.id"] = spanCtx.traceId;
-    }
-
-    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;
-    }
-    logger.emit({
-      severityNumber,
-      severityText: level,
-      body: `[${this.module}] ${message}`,
-      attributes,
-    });
-  }
-}
-
-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/ShutdownHooks.spec.ts

@@ -1,75 +0,0 @@
-import { registerShutdownHooks, shutdownAll } from "./ShutdownHooks";
-
-describe("shutdownAll", () => {
-  it("shuts down every provider", async () => {
-    const first = { shutdown: jest.fn().mockResolvedValue(undefined) };
-    const second = { shutdown: jest.fn().mockResolvedValue(undefined) };
-
-    await shutdownAll([first, second]);
-
-    expect(first.shutdown).toHaveBeenCalledTimes(1);
-    expect(second.shutdown).toHaveBeenCalledTimes(1);
-  });
-
-  it("resolves when a provider fails and reports it", async () => {
-    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
-    const failure = new Error("boom");
-    const failing = { shutdown: jest.fn().mockRejectedValue(failure) };
-    const healthy = { shutdown: jest.fn().mockResolvedValue(undefined) };
-
-    await expect(shutdownAll([failing, healthy])).resolves.toBeUndefined();
-
-    expect(healthy.shutdown).toHaveBeenCalledTimes(1);
-    expect(warnSpy).toHaveBeenCalledWith(
-      "[otel-utils] shutdown failed",
-      failure,
-    );
-    warnSpy.mockRestore();
-  });
-});
-
-describe("registerShutdownHooks", () => {
-  it("flushes the providers and exits once on SIGTERM/SIGINT", async () => {
-    const exitSpy = jest
-      .spyOn(process, "exit")
-      .mockImplementation((() => undefined) as never);
-    const provider = { shutdown: jest.fn().mockResolvedValue(undefined) };
-    const sigtermListeners = process.listenerCount("SIGTERM");
-    const sigintListeners = process.listenerCount("SIGINT");
-
-    const cleanup = registerShutdownHooks([provider]);
-    try {
-      expect(process.listenerCount("SIGTERM")).toBe(sigtermListeners + 1);
-      expect(process.listenerCount("SIGINT")).toBe(sigintListeners + 1);
-
-      process.emit("SIGTERM");
-      await new Promise((resolve) => setImmediate(resolve));
-      expect(provider.shutdown).toHaveBeenCalledTimes(1);
-      expect(exitSpy).toHaveBeenCalledWith(0);
-
-      process.emit("SIGINT");
-      await new Promise((resolve) => setImmediate(resolve));
-      expect(provider.shutdown).toHaveBeenCalledTimes(1);
-      expect(exitSpy).toHaveBeenCalledTimes(1);
-    } finally {
-      cleanup();
-      exitSpy.mockRestore();
-    }
-
-    expect(process.listenerCount("SIGTERM")).toBe(sigtermListeners);
-    expect(process.listenerCount("SIGINT")).toBe(sigintListeners);
-  });
-
-  it("the cleanup function removes both listeners without shutting down", () => {
-    const provider = { shutdown: jest.fn().mockResolvedValue(undefined) };
-    const sigtermListeners = process.listenerCount("SIGTERM");
-    const sigintListeners = process.listenerCount("SIGINT");
-
-    const cleanup = registerShutdownHooks([provider]);
-    cleanup();
-
-    expect(process.listenerCount("SIGTERM")).toBe(sigtermListeners);
-    expect(process.listenerCount("SIGINT")).toBe(sigintListeners);
-    expect(provider.shutdown).not.toHaveBeenCalled();
-  });
-});

package/src/ShutdownHooks.ts

@@ -1,45 +0,0 @@
-export interface ShutdownableInterface {
-  shutdown(): Promise<void>;
-}
-
-/**
- * Flushes and shuts down every provider, resolving even when one of them
- * fails (the failure is reported with `console.warn`).
- */
-export async function shutdownAll(
-  providers: ReadonlyArray<ShutdownableInterface>,
-): Promise<void> {
-  await Promise.all(
-    providers.map((provider) =>
-      provider.shutdown().catch((error: unknown) => {
-        console.warn("[otel-utils] shutdown failed", error);
-      }),
-    ),
-  );
-}
-
-/**
- * Registers one-shot `SIGTERM`/`SIGINT` handlers that flush and shut down all
- * providers, then exit the process with code 0.
- *
- * Register once with every configured provider. The returned function removes
- * the handlers without shutting anything down.
- */
-export function registerShutdownHooks(
-  providers: ReadonlyArray<ShutdownableInterface>,
-): () => void {
-  let shuttingDown = false;
-  const onSignal = (): void => {
-    if (shuttingDown) {
-      return;
-    }
-    shuttingDown = true;
-    void shutdownAll(providers).then(() => process.exit(0));
-  };
-  process.once("SIGTERM", onSignal);
-  process.once("SIGINT", onSignal);
-  return () => {
-    process.removeListener("SIGTERM", onSignal);
-    process.removeListener("SIGINT", onSignal);
-  };
-}