@abbacchio/transport 0.1.1 → 0.1.3

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 };

package/src/transports/winston.ts

@@ -1,100 +1,100 @@
-import TransportStream from "winston-transport";
-import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
-
-export interface WinstonTransportOptions extends AbbacchioClientOptions {
-  /** Winston log level (optional) */
-  level?: string;
-}
-
-/**
- * Winston transport for Abbacchio.
- * Extends winston-transport for proper integration.
- *
- * @example
- * ```typescript
- * import winston from "winston";
- * import { AbbacchioWinstonTransport } from "@abbacchio/client/transports/winston";
- *
- * const logger = winston.createLogger({
- *   transports: [
- *     new winston.transports.Console(),
- *     new AbbacchioWinstonTransport({
- *       url: "http://localhost:4000/api/logs",
- *       channel: "my-app",
- *       secretKey: "optional-encryption-key",
- *     }),
- *   ],
- * });
- *
- * logger.info("Hello from Winston!");
- * ```
- */
-export class AbbacchioWinstonTransport extends TransportStream {
-  private client: AbbacchioClient;
-
-  constructor(opts: WinstonTransportOptions = {}) {
-    super({ level: opts.level });
-    this.client = new AbbacchioClient(opts);
-  }
-
-  /**
-   * Winston log method - called for each log entry
-   */
-  log(info: Record<string, unknown>, callback: () => void): void {
-    setImmediate(() => {
-      this.emit("logged", info);
-    });
-
-    // Transform Winston format to Abbacchio format
-    const log = this.transformLog(info);
-    this.client.add(log);
-
-    callback();
-  }
-
-  /**
-   * Transform Winston log format to a normalized format
-   */
-  private transformLog(info: Record<string, unknown>): Record<string, unknown> {
-    const { level, message, timestamp, ...rest } = info;
-
-    return {
-      level: this.levelToNumber(level as string),
-      msg: message,
-      time: timestamp ? new Date(timestamp as string).getTime() : Date.now(),
-      ...rest,
-    };
-  }
-
-  /**
-   * Convert Winston level string to Pino-style number
-   */
-  private levelToNumber(level: string): number {
-    const levels: Record<string, number> = {
-      error: 50,
-      warn: 40,
-      info: 30,
-      http: 30,
-      verbose: 20,
-      debug: 20,
-      silly: 10,
-    };
-    return levels[level] || 30;
-  }
-
-  /**
-   * Close the transport
-   */
-  close(): void {
-    this.client.close();
-  }
-}
-
-/**
- * Factory function to create a Winston transport
- */
-export function winstonTransport(opts?: WinstonTransportOptions): AbbacchioWinstonTransport {
-  return new AbbacchioWinstonTransport(opts);
-}
-
-export default winstonTransport;
+import TransportStream from "winston-transport";
+import { AbbacchioClient, type AbbacchioClientOptions } from "../client.js";
+
+export interface WinstonTransportOptions extends AbbacchioClientOptions {
+  /** Winston log level (optional) */
+  level?: string;
+}
+
+/**
+ * Winston transport for Abbacchio.
+ * Extends winston-transport for proper integration.
+ *
+ * @example
+ * ```typescript
+ * import winston from "winston";
+ * import { AbbacchioWinstonTransport } from "@abbacchio/client/transports/winston";
+ *
+ * const logger = winston.createLogger({
+ *   transports: [
+ *     new winston.transports.Console(),
+ *     new AbbacchioWinstonTransport({
+ *       url: "http://localhost:4000/api/logs",
+ *       channel: "my-app",
+ *       secretKey: "optional-encryption-key",
+ *     }),
+ *   ],
+ * });
+ *
+ * logger.info("Hello from Winston!");
+ * ```
+ */
+export class AbbacchioWinstonTransport extends TransportStream {
+  private client: AbbacchioClient;
+
+  constructor(opts: WinstonTransportOptions = {}) {
+    super({ level: opts.level });
+    this.client = new AbbacchioClient(opts);
+  }
+
+  /**
+   * Winston log method - called for each log entry
+   */
+  log(info: Record<string, unknown>, callback: () => void): void {
+    setImmediate(() => {
+      this.emit("logged", info);
+    });
+
+    // Transform Winston format to Abbacchio format
+    const log = this.transformLog(info);
+    this.client.add(log);
+
+    callback();
+  }
+
+  /**
+   * Transform Winston log format to a normalized format
+   */
+  private transformLog(info: Record<string, unknown>): Record<string, unknown> {
+    const { level, message, timestamp, ...rest } = info;
+
+    return {
+      level: this.levelToNumber(level as string),
+      msg: message,
+      time: timestamp ? new Date(timestamp as string).getTime() : Date.now(),
+      ...rest,
+    };
+  }
+
+  /**
+   * Convert Winston level string to Pino-style number
+   */
+  private levelToNumber(level: string): number {
+    const levels: Record<string, number> = {
+      error: 50,
+      warn: 40,
+      info: 30,
+      http: 30,
+      verbose: 20,
+      debug: 20,
+      silly: 10,
+    };
+    return levels[level] || 30;
+  }
+
+  /**
+   * Close the transport
+   */
+  close(): void {
+    this.client.close();
+  }
+}
+
+/**
+ * Factory function to create a Winston transport
+ */
+export function winstonTransport(opts?: WinstonTransportOptions): AbbacchioWinstonTransport {
+  return new AbbacchioWinstonTransport(opts);
+}
+
+export default winstonTransport;

package/tsconfig.json

@@ -1,19 +1,19 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}