evlog 1.0.1 → 1.2.0

package/README.md

@@ -94,7 +94,6 @@ export default defineNuxtConfig({
   evlog: {
     env: {
       service: 'my-app',
-      environment: process.env.NODE_ENV,
     },
     // Optional: only log specific routes (supports glob patterns)
     include: ['/api/**'],
@@ -102,6 +101,17 @@ export default defineNuxtConfig({
 })
 ```
 
+> **Tip:** Use `$production` to enable [sampling](#sampling) only in production:
+> ```typescript
+> export default defineNuxtConfig({
+>   modules: ['evlog/nuxt'],
+>   evlog: { env: { service: 'my-app' } },
+>   $production: {
+>     evlog: { sampling: { rates: { info: 10, warn: 50, debug: 0 } } },
+>   },
+> })
+> ```
+
 That's it. Now use `useLogger(event)` in any API route:
 
 ```typescript
@@ -353,6 +363,77 @@ initLogger({
   },
   pretty?: boolean       // Pretty print (default: true in dev)
   include?: string[]     // Route patterns to log (glob), e.g. ['/api/**']
+  sampling?: {
+    rates?: {            // Head sampling (random per level)
+      info?: number      // 0-100, default 100
+      warn?: number      // 0-100, default 100
+      debug?: number     // 0-100, default 100
+      error?: number     // 0-100, default 100 (always logged unless set to 0)
+    }
+    keep?: Array<{       // Tail sampling (force keep based on outcome)
+      status?: number    // Keep if status >= value
+      duration?: number  // Keep if duration >= value (ms)
+      path?: string      // Keep if path matches glob pattern
+    }>
+  }
+})
+```
+
+### Sampling
+
+At scale, logging everything can become expensive. evlog supports two sampling strategies:
+
+#### Head Sampling (rates)
+
+Random sampling based on log level, decided before the request completes:
+
+```typescript
+initLogger({
+  sampling: {
+    rates: {
+      info: 10,   // Keep 10% of info logs
+      warn: 50,   // Keep 50% of warning logs
+      debug: 0,   // Disable debug logs
+      // error defaults to 100% (always logged)
+    },
+  },
+})
+```
+
+#### Tail Sampling (keep)
+
+Force-keep logs based on request outcome, evaluated after the request completes. Useful to always capture slow requests or critical paths:
+
+```typescript
+// nuxt.config.ts
+export default defineNuxtConfig({
+  modules: ['evlog/nuxt'],
+  evlog: {
+    sampling: {
+      rates: { info: 10 },  // Only 10% of info logs
+      keep: [
+        { duration: 1000 },           // Always keep if duration >= 1000ms
+        { status: 400 },              // Always keep if status >= 400
+        { path: '/api/critical/**' }, // Always keep critical paths
+      ],
+    },
+  },
+})
+```
+
+#### Custom Tail Sampling Hook
+
+For business-specific conditions (premium users, feature flags), use the `evlog:emit:keep` Nitro hook:
+
+```typescript
+// server/plugins/evlog-custom.ts
+export default defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook('evlog:emit:keep', (ctx) => {
+    // Always keep logs for premium users
+    if (ctx.context.user?.premium) {
+      ctx.shouldKeep = true
+    }
+  })
 })
 ```
 

package/dist/error.d.mts

@@ -16,16 +16,23 @@ import { ErrorOptions } from './types.mjs';
  * ```
  */
 declare class EvlogError extends Error {
+    /** HTTP status code */
     readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
+    /** HTTP status text (alias for message) */
+    get statusText(): string;
+    /** HTTP status code (alias for compatibility) */
     get statusCode(): number;
+    /** HTTP status message (alias for compatibility) */
+    get statusMessage(): string;
+    /** Structured data for serialization */
     get data(): {
-        why: string | undefined;
-        fix: string | undefined;
-        link: string | undefined;
+        why?: string;
+        fix?: string;
+        link?: string;
     } | undefined;
     toString(): string;
     toJSON(): Record<string, unknown>;
@@ -34,7 +41,7 @@ declare class EvlogError extends Error {
  * Create a structured error with context for debugging and user-facing messages.
  *
  * @param options - Error message string or full options object
- * @returns EvlogError instance compatible with Nitro's error handling
+ * @returns EvlogError with HTTP metadata (`status`, `statusText`) and `data`; also includes `statusCode` and `statusMessage` for legacy compatibility
  *
  * @example
  * ```ts
@@ -52,6 +59,5 @@ declare class EvlogError extends Error {
  * ```
  */
 declare function createError(options: ErrorOptions | string): EvlogError;
-declare const createEvlogError: typeof createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };

package/dist/error.d.ts

@@ -16,16 +16,23 @@ import { ErrorOptions } from './types.js';
  * ```
  */
 declare class EvlogError extends Error {
+    /** HTTP status code */
     readonly status: number;
     readonly why?: string;
     readonly fix?: string;
     readonly link?: string;
     constructor(options: ErrorOptions | string);
+    /** HTTP status text (alias for message) */
+    get statusText(): string;
+    /** HTTP status code (alias for compatibility) */
     get statusCode(): number;
+    /** HTTP status message (alias for compatibility) */
+    get statusMessage(): string;
+    /** Structured data for serialization */
     get data(): {
-        why: string | undefined;
-        fix: string | undefined;
-        link: string | undefined;
+        why?: string;
+        fix?: string;
+        link?: string;
     } | undefined;
     toString(): string;
     toJSON(): Record<string, unknown>;
@@ -34,7 +41,7 @@ declare class EvlogError extends Error {
  * Create a structured error with context for debugging and user-facing messages.
  *
  * @param options - Error message string or full options object
- * @returns EvlogError instance compatible with Nitro's error handling
+ * @returns EvlogError with HTTP metadata (`status`, `statusText`) and `data`; also includes `statusCode` and `statusMessage` for legacy compatibility
  *
  * @example
  * ```ts
@@ -52,6 +59,5 @@ declare class EvlogError extends Error {
  * ```
  */
 declare function createError(options: ErrorOptions | string): EvlogError;
-declare const createEvlogError: typeof createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };

package/dist/error.mjs

@@ -1,6 +1,7 @@
 import { colors, isServer } from './utils.mjs';
 
 class EvlogError extends Error {
+  /** HTTP status code */
   status;
   why;
   fix;
@@ -17,11 +18,24 @@ class EvlogError extends Error {
       Error.captureStackTrace(this, EvlogError);
     }
   }
+  /** HTTP status text (alias for message) */
+  get statusText() {
+    return this.message;
+  }
+  /** HTTP status code (alias for compatibility) */
   get statusCode() {
     return this.status;
   }
+  /** HTTP status message (alias for compatibility) */
+  get statusMessage() {
+    return this.message;
+  }
+  /** Structured data for serialization */
   get data() {
-    return this.why || this.fix || this.link ? { why: this.why, fix: this.fix, link: this.link } : void 0;
+    if (this.why || this.fix || this.link) {
+      return { why: this.why, fix: this.fix, link: this.link };
+    }
+    return void 0;
   }
   toString() {
     const useColors = isServer();
@@ -48,21 +62,20 @@ class EvlogError extends Error {
     return lines.join("\n");
   }
   toJSON() {
+    const { data } = this;
     return {
       name: this.name,
       message: this.message,
       status: this.status,
-      why: this.why,
-      fix: this.fix,
-      link: this.link,
-      cause: this.cause instanceof Error ? { name: this.cause.name, message: this.cause.message } : void 0,
-      stack: this.stack
+      ...data && { data },
+      ...this.cause instanceof Error && {
+        cause: { name: this.cause.name, message: this.cause.message }
+      }
     };
   }
 }
 function createError(options) {
   return new EvlogError(options);
 }
-const createEvlogError = createError;
 
-export { EvlogError, createError, createEvlogError };
+export { EvlogError, createError, createError as createEvlogError };

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-export { EvlogError, createError, createEvlogError } from './error.mjs';
-export { createRequestLogger, getEnvironment, initLogger, log } from './logger.mjs';
+export { EvlogError, createError, createError as createEvlogError } from './error.mjs';
+export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from './logger.mjs';
 export { useLogger } from './runtime/server/useLogger.mjs';
 export { parseError } from './runtime/utils/parseError.mjs';
-export { BaseWideEvent, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, ServerEvent, WideEvent } from './types.mjs';
+export { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, IngestPayload, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent } from './types.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { EvlogError, createError, createEvlogError } from './error.js';
-export { createRequestLogger, getEnvironment, initLogger, log } from './logger.js';
+export { EvlogError, createError, createError as createEvlogError } from './error.js';
+export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from './logger.js';
 export { useLogger } from './runtime/server/useLogger.js';
 export { parseError } from './runtime/utils/parseError.js';
-export { BaseWideEvent, EnvironmentContext, ErrorOptions, H3EventContext, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, ServerEvent, WideEvent } from './types.js';
+export { BaseWideEvent, DrainContext, EnvironmentContext, ErrorOptions, H3EventContext, IngestPayload, Log, LogLevel, LoggerConfig, ParsedError, RequestLogger, RequestLoggerOptions, SamplingConfig, SamplingRates, ServerEvent, TailSamplingCondition, TailSamplingContext, TransportConfig, WideEvent } from './types.js';

package/dist/index.mjs

@@ -1,5 +1,6 @@
-export { EvlogError, createError, createEvlogError } from './error.mjs';
-export { createRequestLogger, getEnvironment, initLogger, log } from './logger.mjs';
+export { EvlogError, createError, createError as createEvlogError } from './error.mjs';
+export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep } from './logger.mjs';
 export { useLogger } from './runtime/server/useLogger.mjs';
 export { parseError } from './runtime/utils/parseError.mjs';
 import './utils.mjs';
+import 'defu';

package/dist/logger.d.mts

@@ -1,10 +1,15 @@
-import { RequestLoggerOptions, RequestLogger, EnvironmentContext, LoggerConfig, Log } from './types.mjs';
+import { RequestLoggerOptions, RequestLogger, EnvironmentContext, LoggerConfig, Log, TailSamplingContext } from './types.mjs';
 
 /**
  * Initialize the logger with configuration.
  * Call this once at application startup.
  */
 declare function initLogger(config?: LoggerConfig): void;
+/**
+ * Evaluate tail sampling conditions to determine if a log should be force-kept.
+ * Returns true if ANY condition matches (OR logic).
+ */
+declare function shouldKeep(ctx: TailSamplingContext): boolean;
 /**
  * Simple logging API - as easy as console.log
  *
@@ -32,4 +37,4 @@ declare function createRequestLogger(options?: RequestLoggerOptions): RequestLog
  */
 declare function getEnvironment(): EnvironmentContext;
 
-export { createRequestLogger, getEnvironment, initLogger, log };
+export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep };

package/dist/logger.d.ts

@@ -1,10 +1,15 @@
-import { RequestLoggerOptions, RequestLogger, EnvironmentContext, LoggerConfig, Log } from './types.js';
+import { RequestLoggerOptions, RequestLogger, EnvironmentContext, LoggerConfig, Log, TailSamplingContext } from './types.js';
 
 /**
  * Initialize the logger with configuration.
  * Call this once at application startup.
  */
 declare function initLogger(config?: LoggerConfig): void;
+/**
+ * Evaluate tail sampling conditions to determine if a log should be force-kept.
+ * Returns true if ANY condition matches (OR logic).
+ */
+declare function shouldKeep(ctx: TailSamplingContext): boolean;
 /**
  * Simple logging API - as easy as console.log
  *
@@ -32,4 +37,4 @@ declare function createRequestLogger(options?: RequestLoggerOptions): RequestLog
  */
 declare function getEnvironment(): EnvironmentContext;
 
-export { createRequestLogger, getEnvironment, initLogger, log };
+export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep };

package/dist/logger.mjs

@@ -1,10 +1,12 @@
-import { isDev, detectEnvironment, formatDuration, getConsoleMethod, colors, getLevelColor } from './utils.mjs';
+import { defu } from 'defu';
+import { isDev, detectEnvironment, formatDuration, matchesPattern, getConsoleMethod, colors, getLevelColor } from './utils.mjs';
 
 let globalEnv = {
   service: "app",
   environment: "development"
 };
 let globalPretty = isDev();
+let globalSampling = {};
 function initLogger(config = {}) {
   const detected = detectEnvironment();
   globalEnv = {
@@ -15,8 +17,38 @@ function initLogger(config = {}) {
     region: config.env?.region ?? detected.region
   };
   globalPretty = config.pretty ?? isDev();
+  globalSampling = config.sampling ?? {};
 }
-function emitWideEvent(level, event) {
+function shouldSample(level) {
+  const { rates } = globalSampling;
+  if (!rates) {
+    return true;
+  }
+  const percentage = level === "error" && rates.error === void 0 ? 100 : rates[level] ?? 100;
+  if (percentage <= 0) return false;
+  if (percentage >= 100) return true;
+  return Math.random() * 100 < percentage;
+}
+function shouldKeep(ctx) {
+  const { keep } = globalSampling;
+  if (!keep?.length) return false;
+  return keep.some((condition) => {
+    if (condition.status !== void 0 && ctx.status !== void 0 && ctx.status >= condition.status) {
+      return true;
+    }
+    if (condition.duration !== void 0 && ctx.duration !== void 0 && ctx.duration >= condition.duration) {
+      return true;
+    }
+    if (condition.path && ctx.path && matchesPattern(ctx.path, condition.path)) {
+      return true;
+    }
+    return false;
+  });
+}
+function emitWideEvent(level, event, skipSamplingCheck = false) {
+  if (!skipSamplingCheck && !shouldSample(level)) {
+    return null;
+  }
   const formatted = {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     level,
@@ -28,9 +60,13 @@ function emitWideEvent(level, event) {
   } else {
     console[getConsoleMethod(level)](JSON.stringify(formatted));
   }
+  return formatted;
 }
 function emitTaggedLog(level, tag, message) {
   if (globalPretty) {
+    if (!shouldSample(level)) {
+      return;
+    }
     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}`);
@@ -114,13 +150,12 @@ function createRequestLogger(options = {}) {
   let hasError = false;
   return {
     set(data) {
-      context = { ...context, ...data };
+      context = defu(data, context);
     },
     error(error, errorContext) {
       hasError = true;
       const err = typeof error === "string" ? new Error(error) : error;
-      context = {
-        ...context,
+      const errorData = {
         ...errorContext,
         error: {
           name: err.name,
@@ -128,15 +163,29 @@ function createRequestLogger(options = {}) {
           stack: err.stack
         }
       };
+      context = defu(errorData, context);
     },
     emit(overrides) {
-      const duration = formatDuration(Date.now() - startTime);
+      const durationMs = Date.now() - startTime;
+      const duration = formatDuration(durationMs);
       const level = hasError ? "error" : "info";
-      emitWideEvent(level, {
+      const { _forceKeep, ...restOverrides } = overrides ?? {};
+      const tailCtx = {
+        status: context.status ?? restOverrides.status,
+        duration: durationMs,
+        path: context.path,
+        method: context.method,
+        context: { ...context, ...restOverrides }
+      };
+      const forceKeep = _forceKeep || shouldKeep(tailCtx);
+      if (!forceKeep && !shouldSample(level)) {
+        return null;
+      }
+      return emitWideEvent(level, {
         ...context,
-        ...overrides,
+        ...restOverrides,
         duration
-      });
+      }, true);
     },
     getContext() {
       return { ...context };
@@ -147,4 +196,4 @@ function getEnvironment() {
   return { ...globalEnv };
 }
 
-export { createRequestLogger, getEnvironment, initLogger, log };
+export { createRequestLogger, getEnvironment, initLogger, log, shouldKeep };

package/dist/nitro/errorHandler.d.mts

@@ -0,0 +1,13 @@
+import * as nitropack from 'nitropack';
+
+/**
+ * Custom Nitro error handler that properly serializes EvlogError.
+ * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
+ * in the JSON response regardless of the underlying HTTP framework.
+ *
+ * For non-EvlogError, it preserves Nitro's default response shape while
+ * sanitizing internal error details in production for 5xx errors.
+ */
+declare const _default: nitropack.NitroErrorHandler;
+
+export { _default as default };

package/dist/nitro/errorHandler.d.ts

@@ -0,0 +1,13 @@
+import * as nitropack from 'nitropack';
+
+/**
+ * Custom Nitro error handler that properly serializes EvlogError.
+ * This ensures that 'data' (containing 'why', 'fix', 'link') is preserved
+ * in the JSON response regardless of the underlying HTTP framework.
+ *
+ * For non-EvlogError, it preserves Nitro's default response shape while
+ * sanitizing internal error details in production for 5xx errors.
+ */
+declare const _default: nitropack.NitroErrorHandler;
+
+export { _default as default };

package/dist/nitro/errorHandler.mjs

@@ -0,0 +1,41 @@
+import { defineNitroErrorHandler } from 'nitropack/runtime';
+import { getRequestURL, setResponseStatus, setResponseHeader, send } from 'h3';
+
+const errorHandler = defineNitroErrorHandler((error, event) => {
+  const evlogError = error.name === "EvlogError" ? error : error.cause?.name === "EvlogError" ? error.cause : null;
+  const isDev = process.env.NODE_ENV === "development";
+  const url = getRequestURL(event, { xForwardedHost: true }).pathname;
+  if (!evlogError) {
+    const status2 = error.statusCode ?? error.status ?? 500;
+    const rawMessage = (error.statusText ?? error.statusMessage ?? error.message) || "Internal Server Error";
+    const message = isDev ? rawMessage : status2 >= 500 ? "Internal Server Error" : rawMessage;
+    setResponseStatus(event, status2);
+    setResponseHeader(event, "Content-Type", "application/json");
+    return send(event, JSON.stringify({
+      url,
+      status: status2,
+      statusCode: status2,
+      statusText: message,
+      statusMessage: message,
+      message,
+      error: true
+    }));
+  }
+  const status = evlogError.status ?? evlogError.statusCode ?? 500;
+  setResponseStatus(event, status);
+  setResponseHeader(event, "Content-Type", "application/json");
+  const { data } = evlogError;
+  const statusMessage = evlogError.statusMessage || evlogError.message;
+  return send(event, JSON.stringify({
+    url,
+    status,
+    statusCode: status,
+    statusText: statusMessage,
+    statusMessage,
+    message: evlogError.message,
+    error: true,
+    ...data !== void 0 && { data }
+  }));
+});
+
+export { errorHandler as default };

package/dist/nitro/plugin.mjs

@@ -1,18 +1,38 @@
 import { defineNitroPlugin, useRuntimeConfig } from 'nitropack/runtime';
+import { getHeaders } from 'h3';
 import { initLogger, createRequestLogger } from '../logger.mjs';
-import '../utils.mjs';
+import { matchesPattern } from '../utils.mjs';
+import 'defu';
 
-function matchesPattern(path, pattern) {
-  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\?/g, "[^/]");
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(path);
-}
-function shouldLog(path, include) {
+function shouldLog(path, include, exclude) {
+  if (exclude && exclude.length > 0) {
+    if (exclude.some((pattern) => matchesPattern(path, pattern))) {
+      return false;
+    }
+  }
   if (!include || include.length === 0) {
     return true;
   }
   return include.some((pattern) => matchesPattern(path, pattern));
 }
+const SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "proxy-authorization"
+];
+function getSafeHeaders(event) {
+  const allHeaders = getHeaders(event);
+  const safeHeaders = {};
+  for (const [key, value] of Object.entries(allHeaders)) {
+    if (!SENSITIVE_HEADERS.includes(key.toLowerCase())) {
+      safeHeaders[key] = value;
+    }
+  }
+  return safeHeaders;
+}
 function getResponseStatus(event) {
   if (event.node?.res?.statusCode) {
     return event.node.res.statusCode;
@@ -25,18 +45,31 @@ function getResponseStatus(event) {
   }
   return 200;
 }
+function callDrainHook(nitroApp, emittedEvent, event) {
+  if (emittedEvent) {
+    nitroApp.hooks.callHook("evlog:drain", {
+      event: emittedEvent,
+      request: { method: event.method, path: event.path, requestId: event.context.requestId },
+      headers: getSafeHeaders(event)
+    }).catch((err) => {
+      console.error("[evlog] drain failed:", err);
+    });
+  }
+}
 const plugin = defineNitroPlugin((nitroApp) => {
   const config = useRuntimeConfig();
   const evlogConfig = config.evlog;
   initLogger({
     env: evlogConfig?.env,
-    pretty: evlogConfig?.pretty
+    pretty: evlogConfig?.pretty,
+    sampling: evlogConfig?.sampling
   });
   nitroApp.hooks.hook("request", (event) => {
     const e = event;
-    if (!shouldLog(e.path, evlogConfig?.include)) {
+    if (!shouldLog(e.path, evlogConfig?.include, evlogConfig?.exclude)) {
       return;
     }
+    e.context._evlogStartTime = Date.now();
     const log = createRequestLogger({
       method: e.method,
       path: e.path,
@@ -44,19 +77,50 @@ const plugin = defineNitroPlugin((nitroApp) => {
     });
     e.context.log = log;
   });
-  nitroApp.hooks.hook("afterResponse", (event) => {
+  nitroApp.hooks.hook("error", async (error, { event }) => {
     const e = event;
+    if (!e) return;
     const log = e.context.log;
     if (log) {
-      log.set({ status: getResponseStatus(e) });
-      log.emit();
+      log.error(error);
+      const errorStatus = error.statusCode ?? 500;
+      log.set({ status: errorStatus });
+      const startTime = e.context._evlogStartTime;
+      const durationMs = startTime ? Date.now() - startTime : void 0;
+      const tailCtx = {
+        status: errorStatus,
+        duration: durationMs,
+        path: e.path,
+        method: e.method,
+        context: log.getContext(),
+        shouldKeep: false
+      };
+      await nitroApp.hooks.callHook("evlog:emit:keep", tailCtx);
+      e.context._evlogEmitted = true;
+      const emittedEvent = log.emit({ _forceKeep: tailCtx.shouldKeep });
+      callDrainHook(nitroApp, emittedEvent, e);
     }
   });
-  nitroApp.hooks.hook("error", (error, { event }) => {
+  nitroApp.hooks.hook("afterResponse", async (event) => {
     const e = event;
-    const log = e?.context.log;
+    if (e.context._evlogEmitted) return;
+    const log = e.context.log;
     if (log) {
-      log.error(error);
+      const status = getResponseStatus(e);
+      log.set({ status });
+      const startTime = e.context._evlogStartTime;
+      const durationMs = startTime ? Date.now() - startTime : void 0;
+      const tailCtx = {
+        status,
+        duration: durationMs,
+        path: e.path,
+        method: e.method,
+        context: log.getContext(),
+        shouldKeep: false
+      };
+      await nitroApp.hooks.callHook("evlog:emit:keep", tailCtx);
+      const emittedEvent = log.emit({ _forceKeep: tailCtx.shouldKeep });
+      callDrainHook(nitroApp, emittedEvent, e);
     }
   });
 });