@abbacchio/transport 0.1.0 → 0.1.2

package/src/transports/bunyan.ts

@@ -1,99 +1,99 @@
-import { Writable } from "stream";
-import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
-
-export interface BunyanStreamOptions extends AbbacchioClientOptions {
-  /** Bunyan log level (optional) */
-  level?: number | string;
-}
-
-/**
- * Bunyan stream for Abbacchio.
- * Implements the Node.js Writable stream interface for Bunyan.
- *
- * @example
- * ```typescript
- * import bunyan from "bunyan";
- * import { bunyanStream } from "@abbacchio/client/transports/bunyan";
- *
- * const logger = bunyan.createLogger({
- *   name: "myapp",
- *   streams: [
- *     { stream: process.stdout },
- *     bunyanStream({
- *       url: "http://localhost:4000/api/logs",
- *       channel: "my-app",
- *       secretKey: "optional-encryption-key",
- *     }),
- *   ],
- * });
- *
- * logger.info("Hello from Bunyan!");
- * ```
- */
-export class AbbacchioBunyanStream extends Writable {
-  private client: AbbacchioClient;
-  public level?: number | string;
-
-  constructor(opts: BunyanStreamOptions = {}) {
-    super({ objectMode: true });
-    this.client = new AbbacchioClient(opts);
-    this.level = opts.level;
-  }
-
-  /**
-   * Writable stream _write method - called for each log entry
-   */
-  _write(
-    chunk: Record<string, unknown>,
-    _encoding: BufferEncoding,
-    callback: (error?: Error | null) => void
-  ): void {
-    try {
-      // Transform Bunyan format to Abbacchio format
-      const log = this.transformLog(chunk);
-      this.client.add(log);
-      callback();
-    } catch (err) {
-      callback(err as Error);
-    }
-  }
-
-  /**
-   * Transform Bunyan log format to a normalized format
-   */
-  private transformLog(record: Record<string, unknown>): Record<string, unknown> {
-    const { name, hostname, pid, level, msg, time, v, ...rest } = record;
-
-    return {
-      level: level as number,
-      msg,
-      time: time ? new Date(time as string).getTime() : Date.now(),
-      name,
-      hostname,
-      pid,
-      ...rest,
-    };
-  }
-
-  /**
-   * Close the stream
-   */
-  _final(callback: (error?: Error | null) => void): void {
-    this.client.close().then(() => callback()).catch(callback);
-  }
-}
-
-/**
- * Factory function to create a Bunyan stream
- * Returns an object with stream and optional level for Bunyan's streams array
- */
-export function bunyanStream(opts?: BunyanStreamOptions): { stream: AbbacchioBunyanStream; level?: number | string; type: "raw" } {
-  const stream = new AbbacchioBunyanStream(opts);
-  return {
-    stream,
-    level: opts?.level,
-    type: "raw",
-  };
-}
-
-export default bunyanStream;
+import { Writable } from "stream";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface BunyanStreamOptions extends AbbacchioClientOptions {
+  /** Bunyan log level (optional) */
+  level?: number | string;
+}
+
+/**
+ * Bunyan stream for Abbacchio.
+ * Implements the Node.js Writable stream interface for Bunyan.
+ *
+ * @example
+ * ```typescript
+ * import bunyan from "bunyan";
+ * import { bunyanStream } from "@abbacchio/client/transports/bunyan";
+ *
+ * const logger = bunyan.createLogger({
+ *   name: "myapp",
+ *   streams: [
+ *     { stream: process.stdout },
+ *     bunyanStream({
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Hello from Bunyan!");
+ * ```
+ */
+export class AbbacchioBunyanStream extends Writable {
+  private client: AbbacchioClient;
+  public level?: number | string;
+
+  constructor(opts: BunyanStreamOptions = {}) {
+    super({ objectMode: true });
+    this.client = new AbbacchioClient(opts);
+    this.level = opts.level;
+  }
+
+  /**
+   * Writable stream _write method - called for each log entry
+   */
+  _write(
+    chunk: Record<string, unknown>,
+    _encoding: BufferEncoding,
+    callback: (error?: Error | null) => void
+  ): void {
+    try {
+      // Transform Bunyan format to Abbacchio format
+      const log = this.transformLog(chunk);
+      this.client.add(log);
+      callback();
+    } catch (err) {
+      callback(err as Error);
+    }
+  }
+
+  /**
+   * Transform Bunyan log format to a normalized format
+   */
+  private transformLog(record: Record<string, unknown>): Record<string, unknown> {
+    const { name, hostname, pid, level, msg, time, v, ...rest } = record;
+
+    return {
+      level: level as number,
+      msg,
+      time: time ? new Date(time as string).getTime() : Date.now(),
+      name,
+      hostname,
+      pid,
+      ...rest,
+    };
+  }
+
+  /**
+   * Close the stream
+   */
+  _final(callback: (error?: Error | null) => void): void {
+    this.client.close().then(() => callback()).catch(callback);
+  }
+}
+
+/**
+ * Factory function to create a Bunyan stream
+ * Returns an object with stream and optional level for Bunyan's streams array
+ */
+export function bunyanStream(opts?: BunyanStreamOptions): { stream: AbbacchioBunyanStream; level?: number | string; type: "raw" } {
+  const stream = new AbbacchioBunyanStream(opts);
+  return {
+    stream,
+    level: opts?.level,
+    type: "raw",
+  };
+}
+
+export default bunyanStream;

package/src/transports/console.ts

@@ -1,147 +1,147 @@
-import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
-
-export interface ConsoleInterceptorOptions extends AbbacchioClientOptions {
-  /** Which console methods to intercept. Defaults to all. */
-  methods?: ("log" | "info" | "warn" | "error" | "debug")[];
-  /** Whether to still output to original console. Defaults to true. */
-  passthrough?: boolean;
-}
-
-type ConsoleMethod = "log" | "info" | "warn" | "error" | "debug";
-
-const methodToLevel: Record<ConsoleMethod, number> = {
-  debug: 20,
-  log: 30,
-  info: 30,
-  warn: 40,
-  error: 50,
-};
-
-/**
- * Console interceptor for Abbacchio.
- * Intercepts console.log/info/warn/error/debug calls and sends them to Abbacchio.
- *
- * @example
- * ```typescript
- * import { interceptConsole, restoreConsole } from "@abbacchio/client/transports/console";
- *
- * // Start intercepting console calls
- * interceptConsole({
- *   url: "http://localhost:4000/api/logs",
- *   channel: "my-app",
- *   secretKey: "optional-encryption-key",
- *   passthrough: true, // Still log to console
- * });
- *
- * console.log("This will be sent to Abbacchio!");
- * console.error("Errors too!");
- *
- * // Stop intercepting when done
- * restoreConsole();
- * ```
- */
-
-// Store original console methods
-const originalConsole: Record<ConsoleMethod, (...args: unknown[]) => void> = {
-  log: console.log.bind(console),
-  info: console.info.bind(console),
-  warn: console.warn.bind(console),
-  error: console.error.bind(console),
-  debug: console.debug.bind(console),
-};
-
-let activeClient: AbbacchioClient | null = null;
-let activeOptions: ConsoleInterceptorOptions | null = null;
-
-/**
- * Format console arguments into a message string
- */
-function formatArgs(args: unknown[]): string {
-  return args
-    .map((arg) => {
-      if (typeof arg === "string") return arg;
-      if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack}`;
-      try {
-        return JSON.stringify(arg);
-      } catch {
-        return String(arg);
-      }
-    })
-    .join(" ");
-}
-
-/**
- * Create an intercepted console method
- */
-function createInterceptedMethod(
-  method: ConsoleMethod,
-  client: AbbacchioClient,
-  passthrough: boolean
-): (...args: unknown[]) => void {
-  return (...args: unknown[]) => {
-    // Send to Abbacchio
-    const log = {
-      level: methodToLevel[method],
-      msg: formatArgs(args),
-      time: Date.now(),
-      method,
-    };
-    client.add(log);
-
-    // Optionally pass through to original console
-    if (passthrough) {
-      originalConsole[method](...args);
-    }
-  };
-}
-
-/**
- * Start intercepting console calls
- */
-export function interceptConsole(opts: ConsoleInterceptorOptions = {}): void {
-  // Restore any existing interception first
-  if (activeClient) {
-    restoreConsole();
-  }
-
-  const methods = opts.methods || ["log", "info", "warn", "error", "debug"];
-  const passthrough = opts.passthrough !== false;
-
-  activeClient = new AbbacchioClient(opts);
-  activeOptions = opts;
-
-  // Replace console methods
-  for (const method of methods) {
-    (console as unknown as Record<string, unknown>)[method] = createInterceptedMethod(
-      method,
-      activeClient,
-      passthrough
-    );
-  }
-}
-
-/**
- * Stop intercepting console calls and restore original behavior
- */
-export function restoreConsole(): void {
-  // Restore original console methods
-  for (const method of Object.keys(originalConsole) as ConsoleMethod[]) {
-    (console as unknown as Record<string, unknown>)[method] = originalConsole[method];
-  }
-
-  // Flush and close client
-  if (activeClient) {
-    activeClient.close();
-    activeClient = null;
-    activeOptions = null;
-  }
-}
-
-/**
- * Get the active client (for testing)
- */
-export function getActiveClient(): AbbacchioClient | null {
-  return activeClient;
-}
-
-export default interceptConsole;
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface ConsoleInterceptorOptions extends AbbacchioClientOptions {
+  /** Which console methods to intercept. Defaults to all. */
+  methods?: ("log" | "info" | "warn" | "error" | "debug")[];
+  /** Whether to still output to original console. Defaults to true. */
+  passthrough?: boolean;
+}
+
+type ConsoleMethod = "log" | "info" | "warn" | "error" | "debug";
+
+const methodToLevel: Record<ConsoleMethod, number> = {
+  debug: 20,
+  log: 30,
+  info: 30,
+  warn: 40,
+  error: 50,
+};
+
+/**
+ * Console interceptor for Abbacchio.
+ * Intercepts console.log/info/warn/error/debug calls and sends them to Abbacchio.
+ *
+ * @example
+ * ```typescript
+ * import { interceptConsole, restoreConsole } from "@abbacchio/client/transports/console";
+ *
+ * // Start intercepting console calls
+ * interceptConsole({
+ *   url: "http://localhost:4000/api/logs",
+ *   channel: "my-app",
+ *   secretKey: "optional-encryption-key",
+ *   passthrough: true, // Still log to console
+ * });
+ *
+ * console.log("This will be sent to Abbacchio!");
+ * console.error("Errors too!");
+ *
+ * // Stop intercepting when done
+ * restoreConsole();
+ * ```
+ */
+
+// Store original console methods
+const originalConsole: Record<ConsoleMethod, (...args: unknown[]) => void> = {
+  log: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console),
+};
+
+let activeClient: AbbacchioClient | null = null;
+let activeOptions: ConsoleInterceptorOptions | null = null;
+
+/**
+ * Format console arguments into a message string
+ */
+function formatArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") return arg;
+      if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack}`;
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+/**
+ * Create an intercepted console method
+ */
+function createInterceptedMethod(
+  method: ConsoleMethod,
+  client: AbbacchioClient,
+  passthrough: boolean
+): (...args: unknown[]) => void {
+  return (...args: unknown[]) => {
+    // Send to Abbacchio
+    const log = {
+      level: methodToLevel[method],
+      msg: formatArgs(args),
+      time: Date.now(),
+      method,
+    };
+    client.add(log);
+
+    // Optionally pass through to original console
+    if (passthrough) {
+      originalConsole[method](...args);
+    }
+  };
+}
+
+/**
+ * Start intercepting console calls
+ */
+export function interceptConsole(opts: ConsoleInterceptorOptions = {}): void {
+  // Restore any existing interception first
+  if (activeClient) {
+    restoreConsole();
+  }
+
+  const methods = opts.methods || ["log", "info", "warn", "error", "debug"];
+  const passthrough = opts.passthrough !== false;
+
+  activeClient = new AbbacchioClient(opts);
+  activeOptions = opts;
+
+  // Replace console methods
+  for (const method of methods) {
+    (console as unknown as Record<string, unknown>)[method] = createInterceptedMethod(
+      method,
+      activeClient,
+      passthrough
+    );
+  }
+}
+
+/**
+ * Stop intercepting console calls and restore original behavior
+ */
+export function restoreConsole(): void {
+  // Restore original console methods
+  for (const method of Object.keys(originalConsole) as ConsoleMethod[]) {
+    (console as unknown as Record<string, unknown>)[method] = originalConsole[method];
+  }
+
+  // Flush and close client
+  if (activeClient) {
+    activeClient.close();
+    activeClient = null;
+    activeOptions = null;
+  }
+}
+
+/**
+ * Get the active client (for testing)
+ */
+export function getActiveClient(): AbbacchioClient | null {
+  return activeClient;
+}
+
+export default interceptConsole;

package/src/transports/index.ts

@@ -1,15 +1,15 @@
-// Pino transport
-export { default as pinoTransport } from "./pino.js";
-export type { PinoTransportOptions } from "./pino.js";
-
-// Winston transport
-export { winstonTransport, AbbacchioWinstonTransport } from "./winston.js";
-export type { WinstonTransportOptions } from "./winston.js";
-
-// Bunyan stream
-export { bunyanStream, AbbacchioBunyanStream } from "./bunyan.js";
-export type { BunyanStreamOptions } from "./bunyan.js";
-
-// Console interceptor
-export { interceptConsole, restoreConsole, getActiveClient } from "./console.js";
-export type { ConsoleInterceptorOptions } from "./console.js";
+// Pino transport
+export { default as pinoTransport } from "./pino.js";
+export type { PinoTransportOptions } from "./pino.js";
+
+// Winston transport
+export { winstonTransport, AbbacchioWinstonTransport } from "./winston.js";
+export type { WinstonTransportOptions } from "./winston.js";
+
+// Bunyan stream
+export { bunyanStream, AbbacchioBunyanStream } from "./bunyan.js";
+export type { BunyanStreamOptions } from "./bunyan.js";
+
+// Console interceptor
+export { interceptConsole, restoreConsole, getActiveClient } from "./console.js";
+export type { ConsoleInterceptorOptions } from "./console.js";

package/src/transports/pino.ts

@@ -1,49 +1,49 @@
-import build from "pino-abstract-transport";
-import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
-
-export interface PinoTransportOptions extends AbbacchioClientOptions {}
-
-/**
- * Pino transport for Abbacchio.
- *
- * @example
- * ```typescript
- * import pino from "pino";
- *
- * const logger = pino({
- *   transport: {
- *     target: "@abbacchio/client/transports/pino",
- *     options: {
- *       url: "http://localhost:4000/api/logs",
- *       channel: "my-app",
- *       secretKey: "optional-encryption-key",
- *     },
- *   },
- * });
- *
- * logger.info("Hello from Pino!");
- * ```
- */
-export default async function pinoTransport(opts: PinoTransportOptions = {}) {
-  const client = new AbbacchioClient(opts);
-
-  return build(
-    async function (source) {
-      for await (const obj of source) {
-        client.add(obj);
-      }
-      // Flush remaining on close
-      await client.flush();
-    },
-    {
-      async close() {
-        await client.close();
-      },
-    }
-  );
-}
-
-/**
- * Named export for programmatic usage
- */
-export { pinoTransport };
+import build from "pino-abstract-transport";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface PinoTransportOptions extends AbbacchioClientOptions {}
+
+/**
+ * Pino transport for Abbacchio.
+ *
+ * @example
+ * ```typescript
+ * import pino from "pino";
+ *
+ * const logger = pino({
+ *   transport: {
+ *     target: "@abbacchio/client/transports/pino",
+ *     options: {
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     },
+ *   },
+ * });
+ *
+ * logger.info("Hello from Pino!");
+ * ```
+ */
+export default async function pinoTransport(opts: PinoTransportOptions = {}) {
+  const client = new AbbacchioClient(opts);
+
+  return build(
+    async function (source) {
+      for await (const obj of source) {
+        client.add(obj);
+      }
+      // Flush remaining on close
+      await client.flush();
+    },
+    {
+      async close() {
+        await client.close();
+      },
+    }
+  );
+}
+
+/**
+ * Named export for programmatic usage
+ */
+export { pinoTransport };