evlog 0.0.0-reserved → 0.1.0

package/dist/logger.mjs

@@ -0,0 +1,134 @@
+import { isDev, detectEnvironment, formatDuration, colors, getLevelColor } from './utils.mjs';
+
+let globalEnv = {
+  service: "app",
+  environment: "development"
+};
+let globalPretty = isDev();
+function initLogger(config = {}) {
+  const detected = detectEnvironment();
+  globalEnv = {
+    service: config.env?.service ?? detected.service ?? "app",
+    environment: config.env?.environment ?? detected.environment ?? "development",
+    version: config.env?.version ?? detected.version,
+    commitHash: config.env?.commitHash ?? detected.commitHash,
+    region: config.env?.region ?? detected.region
+  };
+  globalPretty = config.pretty ?? isDev();
+}
+function getConsoleMethod(level) {
+  return level === "error" ? "error" : level === "warn" ? "warn" : "log";
+}
+function emitWideEvent(level, event) {
+  const formatted = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    ...globalEnv,
+    ...event
+  };
+  if (globalPretty) {
+    prettyPrintWideEvent(formatted);
+  } else {
+    console[getConsoleMethod(level)](JSON.stringify(formatted));
+  }
+}
+function emitTaggedLog(level, tag, message) {
+  if (globalPretty) {
+    const color = getLevelColor(level);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+    console.log(`${colors.dim}${timestamp}${colors.reset} ${color}[${tag}]${colors.reset} ${message}`);
+  } else {
+    emitWideEvent(level, { tag, message });
+  }
+}
+function prettyPrintWideEvent(event) {
+  const { timestamp, level, service, environment, version, ...rest } = event;
+  const levelColor = getLevelColor(level);
+  const ts = timestamp.slice(11, 23);
+  let header = `${colors.dim}${ts}${colors.reset} ${levelColor}${level.toUpperCase()}${colors.reset}`;
+  header += ` ${colors.cyan}[${service}]${colors.reset}`;
+  if (rest.method && rest.path) {
+    header += ` ${rest.method} ${rest.path}`;
+    delete rest.method;
+    delete rest.path;
+  }
+  if (rest.duration) {
+    header += ` ${colors.dim}${rest.duration}${colors.reset}`;
+    delete rest.duration;
+  }
+  if (rest.status) {
+    const statusColor = rest.status >= 400 ? colors.red : colors.green;
+    header += ` ${statusColor}${rest.status}${colors.reset}`;
+    delete rest.status;
+  }
+  console.log(header);
+  if (Object.keys(rest).length > 0) {
+    for (const [key, value] of Object.entries(rest)) {
+      if (value !== void 0) {
+        const formatted = typeof value === "object" ? JSON.stringify(value) : value;
+        console.log(`  ${colors.dim}${key}:${colors.reset} ${formatted}`);
+      }
+    }
+  }
+}
+function createLogMethod(level) {
+  return function logMethod(tagOrEvent, message) {
+    if (typeof tagOrEvent === "string" && message !== void 0) {
+      emitTaggedLog(level, tagOrEvent, message);
+    } else if (typeof tagOrEvent === "object") {
+      emitWideEvent(level, tagOrEvent);
+    } else {
+      emitTaggedLog(level, "log", String(tagOrEvent));
+    }
+  };
+}
+const log = {
+  info: createLogMethod("info"),
+  error: createLogMethod("error"),
+  warn: createLogMethod("warn"),
+  debug: createLogMethod("debug")
+};
+function createRequestLogger(options = {}) {
+  const startTime = Date.now();
+  let context = {
+    method: options.method,
+    path: options.path,
+    requestId: options.requestId
+  };
+  let hasError = false;
+  return {
+    set(data) {
+      context = { ...context, ...data };
+    },
+    error(error, errorContext) {
+      hasError = true;
+      const err = typeof error === "string" ? new Error(error) : error;
+      context = {
+        ...context,
+        ...errorContext,
+        error: {
+          name: err.name,
+          message: err.message,
+          stack: err.stack
+        }
+      };
+    },
+    emit(overrides) {
+      const duration = formatDuration(Date.now() - startTime);
+      const level = hasError ? "error" : "info";
+      emitWideEvent(level, {
+        ...context,
+        ...overrides,
+        duration
+      });
+    },
+    getContext() {
+      return { ...context };
+    }
+  };
+}
+function getEnvironment() {
+  return { ...globalEnv };
+}
+
+export { createRequestLogger, getEnvironment, initLogger, log };

package/dist/nitro/plugin.d.mts

@@ -0,0 +1,5 @@
+import * as nitropack from 'nitropack';
+
+declare const _default: nitropack.NitroAppPlugin;
+
+export { _default as default };

package/dist/nitro/plugin.d.ts

@@ -0,0 +1,5 @@
+import * as nitropack from 'nitropack';
+
+declare const _default: nitropack.NitroAppPlugin;
+
+export { _default as default };

package/dist/nitro/plugin.mjs

@@ -0,0 +1,33 @@
+import { defineNitroPlugin } from 'nitropack/runtime';
+import { initLogger, createRequestLogger } from '../logger.mjs';
+import '../utils.mjs';
+
+function getResponseStatus(event) {
+  return event.node?.res?.statusCode ?? 200;
+}
+const plugin = defineNitroPlugin((nitroApp) => {
+  initLogger();
+  nitroApp.hooks.hook("request", (event) => {
+    const log = createRequestLogger({
+      method: event.method,
+      path: event.path,
+      requestId: event.context.requestId || crypto.randomUUID()
+    });
+    event.context.log = log;
+  });
+  nitroApp.hooks.hook("afterResponse", (event) => {
+    const log = event.context.log;
+    if (log) {
+      log.set({ status: getResponseStatus(event) });
+      log.emit();
+    }
+  });
+  nitroApp.hooks.hook("error", (error, { event }) => {
+    const log = event?.context.log;
+    if (log) {
+      log.error(error);
+    }
+  });
+});
+
+export { plugin as default };

package/dist/nuxt/module.d.mts

@@ -0,0 +1,18 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { EnvironmentContext } from '../types.mjs';
+
+interface ModuleOptions {
+    /**
+     * Environment context overrides.
+     */
+    env?: Partial<EnvironmentContext>;
+    /**
+     * Enable pretty printing.
+     * @default true in development, false in production
+     */
+    pretty?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/nuxt/module.d.ts

@@ -0,0 +1,18 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { EnvironmentContext } from '../types.js';
+
+interface ModuleOptions {
+    /**
+     * Environment context overrides.
+     */
+    env?: Partial<EnvironmentContext>;
+    /**
+     * Enable pretty printing.
+     * @default true in development, false in production
+     */
+    pretty?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/nuxt/module.mjs

@@ -0,0 +1,48 @@
+import { defineNuxtModule, createResolver, addServerPlugin, addPlugin, addImports, addServerImports } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "evlog",
+    configKey: "evlog",
+    docs: "https://github.com/hugorcd/evlog"
+  },
+  defaults: {},
+  setup(options, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.evlog = options;
+    nuxt.options.runtimeConfig.public.evlog = {
+      pretty: options.pretty
+    };
+    addServerPlugin(resolver.resolve("../nitro/plugin"));
+    addPlugin({
+      src: resolver.resolve("../runtime/plugin.client"),
+      mode: "client"
+    });
+    addImports([
+      {
+        name: "log",
+        from: resolver.resolve("../runtime/composables/log")
+      },
+      {
+        name: "defineError",
+        from: resolver.resolve("../error")
+      }
+    ]);
+    addServerImports([
+      {
+        name: "useLogger",
+        from: resolver.resolve("../runtime/composables/useLogger")
+      },
+      {
+        name: "log",
+        from: resolver.resolve("../runtime/composables/log")
+      },
+      {
+        name: "defineError",
+        from: resolver.resolve("../error")
+      }
+    ]);
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/composables/index.d.mts

@@ -0,0 +1,4 @@
+export { initLog, log } from './log.mjs';
+export { useLogger } from './useLogger.mjs';
+import '../../types.mjs';
+import 'h3';

package/dist/runtime/composables/index.d.ts

@@ -0,0 +1,4 @@
+export { initLog, log } from './log.js';
+export { useLogger } from './useLogger.js';
+import '../../types.js';
+import 'h3';

package/dist/runtime/composables/index.mjs

@@ -0,0 +1,2 @@
+export { initLog, log } from './log.mjs';
+export { useLogger } from './useLogger.mjs';

package/dist/runtime/composables/log.d.mts

@@ -0,0 +1,18 @@
+import { Log } from '../../types.mjs';
+
+declare function initLog(options?: {
+    pretty?: boolean;
+    service?: string;
+}): void;
+/**
+ * Universal logging API - works on both client and server.
+ *
+ * @example
+ * ```ts
+ * log.info('auth', 'User logged in')
+ * log.info({ action: 'checkout', items: 3 })
+ * ```
+ */
+declare const log: Log;
+
+export { initLog, log };

package/dist/runtime/composables/log.d.ts

@@ -0,0 +1,18 @@
+import { Log } from '../../types.js';
+
+declare function initLog(options?: {
+    pretty?: boolean;
+    service?: string;
+}): void;
+/**
+ * Universal logging API - works on both client and server.
+ *
+ * @example
+ * ```ts
+ * log.info('auth', 'User logged in')
+ * log.info({ action: 'checkout', items: 3 })
+ * ```
+ */
+declare const log: Log;
+
+export { initLog, log };

package/dist/runtime/composables/log.mjs

@@ -0,0 +1,69 @@
+const IS_CLIENT = typeof window !== "undefined";
+let clientPretty = true;
+let clientService = "client";
+const LEVEL_COLORS = {
+  error: "color: #ef4444; font-weight: bold",
+  warn: "color: #f59e0b; font-weight: bold",
+  info: "color: #06b6d4; font-weight: bold",
+  debug: "color: #6b7280; font-weight: bold"
+};
+function initLog(options = {}) {
+  clientPretty = options.pretty ?? true;
+  clientService = options.service ?? "client";
+}
+function getConsoleMethod(level) {
+  return level === "error" ? "error" : level === "warn" ? "warn" : "log";
+}
+function emitClientWideEvent(level, event) {
+  const formatted = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    service: clientService,
+    ...event
+  };
+  const method = getConsoleMethod(level);
+  if (clientPretty) {
+    const { level: lvl, service, ...rest } = formatted;
+    console[method](`%c[${service}]%c ${lvl}`, LEVEL_COLORS[lvl] || "", "color: inherit", rest);
+  } else {
+    console[method](JSON.stringify(formatted));
+  }
+}
+function emitClientTaggedLog(level, tag, message) {
+  if (clientPretty) {
+    console[getConsoleMethod(level)](`%c[${tag}]%c ${message}`, LEVEL_COLORS[level] || "", "color: inherit");
+  } else {
+    emitClientWideEvent(level, { tag, message });
+  }
+}
+function createLogMethod(level) {
+  return function logMethod(tagOrEvent, message) {
+    if (IS_CLIENT) {
+      if (typeof tagOrEvent === "string" && message !== void 0) {
+        emitClientTaggedLog(level, tagOrEvent, message);
+      } else if (typeof tagOrEvent === "object") {
+        emitClientWideEvent(level, tagOrEvent);
+      } else {
+        emitClientTaggedLog(level, "log", String(tagOrEvent));
+      }
+    } else {
+      import('../../logger.mjs').then(({ log: serverLog }) => {
+        if (typeof tagOrEvent === "string" && message !== void 0) {
+          serverLog[level](tagOrEvent, message);
+        } else if (typeof tagOrEvent === "object") {
+          serverLog[level](tagOrEvent);
+        } else {
+          serverLog[level]("log", String(tagOrEvent));
+        }
+      });
+    }
+  };
+}
+const log = {
+  info: createLogMethod("info"),
+  error: createLogMethod("error"),
+  warn: createLogMethod("warn"),
+  debug: createLogMethod("debug")
+};
+
+export { initLog, log };

package/dist/runtime/composables/useLogger.d.mts

@@ -0,0 +1,21 @@
+import { H3Event } from 'h3';
+import { RequestLogger } from '../../types.mjs';
+
+/**
+ * Get the request-scoped logger from the event context.
+ * Must be called within a server handler with an H3 event.
+ *
+ * @example
+ * ```ts
+ * export default defineEventHandler((event) => {
+ *   const logger = useLogger(event)
+ *   logger.set({ userId: '123' })
+ *   logger.set({ action: 'checkout' })
+ *   return { ok: true }
+ *   // emit() is called automatically by the Nitro plugin
+ * })
+ * ```
+ */
+declare function useLogger(event: H3Event): RequestLogger;
+
+export { useLogger };

package/dist/runtime/composables/useLogger.d.ts

@@ -0,0 +1,21 @@
+import { H3Event } from 'h3';
+import { RequestLogger } from '../../types.js';
+
+/**
+ * Get the request-scoped logger from the event context.
+ * Must be called within a server handler with an H3 event.
+ *
+ * @example
+ * ```ts
+ * export default defineEventHandler((event) => {
+ *   const logger = useLogger(event)
+ *   logger.set({ userId: '123' })
+ *   logger.set({ action: 'checkout' })
+ *   return { ok: true }
+ *   // emit() is called automatically by the Nitro plugin
+ * })
+ * ```
+ */
+declare function useLogger(event: H3Event): RequestLogger;
+
+export { useLogger };

package/dist/runtime/composables/useLogger.mjs

@@ -0,0 +1,11 @@
+function useLogger(event) {
+  const log = event.context.log;
+  if (!log) {
+    throw new Error(
+      '[evlog] Logger not initialized. Make sure the evlog Nitro plugin is registered. If using Nuxt, add "evlog" to your modules.'
+    );
+  }
+  return log;
+}
+
+export { useLogger };

package/dist/runtime/plugin.client.d.mts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export { _default as default };

package/dist/runtime/plugin.client.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export { _default as default };

package/dist/runtime/plugin.client.mjs

@@ -0,0 +1,13 @@
+import { initLog } from './composables/log.mjs';
+import { defineNuxtPlugin, useRuntimeConfig } from '#app';
+
+const plugin_client = defineNuxtPlugin((_nuxtApp) => {
+  const config = useRuntimeConfig();
+  const evlogConfig = config.public?.evlog;
+  initLog({
+    pretty: evlogConfig?.pretty ?? import.meta.dev,
+    service: "client"
+  });
+});
+
+export { plugin_client as default };

package/dist/types.d.mts

@@ -0,0 +1,135 @@
+/**
+ * Environment context automatically included in every log event
+ */
+interface EnvironmentContext {
+    /** Service name (auto-detected from package.json or configurable) */
+    service: string;
+    /** Environment: 'development', 'production', 'test', etc. */
+    environment: 'development' | 'production' | 'test' | string;
+    /** Application version (auto-detected from package.json) */
+    version?: string;
+    /** Git commit hash (auto-detected from CI/CD env vars) */
+    commitHash?: string;
+    /** Deployment region (auto-detected from cloud provider env vars) */
+    region?: string;
+}
+/**
+ * Logger configuration options
+ */
+interface LoggerConfig {
+    /** Environment context overrides */
+    env?: Partial<EnvironmentContext>;
+    /** Enable pretty printing (auto-detected: true in dev, false in prod) */
+    pretty?: boolean;
+}
+/**
+ * Base structure for all wide events
+ */
+interface BaseWideEvent {
+    timestamp: string;
+    level: 'info' | 'error' | 'warn' | 'debug';
+    service: string;
+    environment: string;
+    version?: string;
+    commitHash?: string;
+    region?: string;
+}
+/**
+ * Wide event with arbitrary additional fields
+ */
+type WideEvent = BaseWideEvent & Record<string, unknown>;
+/**
+ * Request-scoped logger for building wide events
+ *
+ * @example
+ * ```ts
+ * const logger = useLogger(event)
+ * logger.set({ user: { id: '123' } })
+ * logger.set({ cart: { items: 3 } })
+ * // emit() is called automatically by the plugin
+ * ```
+ */
+interface RequestLogger {
+    /**
+     * Add context to the wide event (shallow merge)
+     */
+    set: <T extends Record<string, unknown>>(context: T) => void;
+    /**
+     * Log an error and capture its details
+     */
+    error: (error: Error | string, context?: Record<string, unknown>) => void;
+    /**
+     * Emit the final wide event with all accumulated context
+     */
+    emit: (overrides?: Record<string, unknown>) => void;
+    /**
+     * Get the current accumulated context
+     */
+    getContext: () => Record<string, unknown>;
+}
+/**
+ * Log level type
+ */
+type LogLevel = 'info' | 'error' | 'warn' | 'debug';
+/**
+ * Simple logging API - as easy as console.log
+ *
+ * @example
+ * ```ts
+ * log.info('auth', 'User logged in')
+ * log.error({ action: 'payment', error: 'failed' })
+ * ```
+ */
+interface Log {
+    /**
+     * Log an info message or wide event
+     * @example log.info('auth', 'User logged in')
+     * @example log.info({ action: 'login', userId: '123' })
+     */
+    info(tag: string, message: string): void;
+    info(event: Record<string, unknown>): void;
+    /**
+     * Log an error message or wide event
+     * @example log.error('payment', 'Payment failed')
+     * @example log.error({ action: 'payment', error: 'declined' })
+     */
+    error(tag: string, message: string): void;
+    error(event: Record<string, unknown>): void;
+    /**
+     * Log a warning message or wide event
+     * @example log.warn('api', 'Rate limit approaching')
+     * @example log.warn({ action: 'api', remaining: 10 })
+     */
+    warn(tag: string, message: string): void;
+    warn(event: Record<string, unknown>): void;
+    /**
+     * Log a debug message or wide event
+     * @example log.debug('cache', 'Cache miss')
+     * @example log.debug({ action: 'cache', key: 'user_123' })
+     */
+    debug(tag: string, message: string): void;
+    debug(event: Record<string, unknown>): void;
+}
+/**
+ * Error options for creating structured errors
+ */
+interface ErrorOptions {
+    /** What actually happened */
+    message: string;
+    /** Why this error occurred */
+    why?: string;
+    /** How to fix this issue */
+    fix?: string;
+    /** Link to documentation or more information */
+    link?: string;
+    /** The original error that caused this */
+    cause?: Error;
+}
+/**
+ * H3 event context with evlog logger attached
+ */
+interface EvlogEventContext {
+    log?: RequestLogger;
+}
+
+export type { BaseWideEvent, EnvironmentContext, ErrorOptions, EvlogEventContext, Log, LogLevel, LoggerConfig, RequestLogger, WideEvent };