@blyp/core 0.1.2 → 0.1.21

package/dist/index.mjs

@@ -8,6 +8,7 @@ import { gzipSync, gunzipSync } from 'fflate';
 import { randomUUID } from 'crypto';
 import * as Sentry from '@sentry/node';
 import { Logtail } from '@logtail/node';
+import { Databuddy } from '@databuddy/sdk/node';
 import { SeverityNumber } from '@opentelemetry/api-logs';
 import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 import { resourceFromAttributes } from '@opentelemetry/resources';
@@ -197,6 +198,7 @@ var CLIENT_LOG_LEVELS = [
 ];
 var clientConnectorRequestSchema = z.union([
   z.literal("betterstack"),
+  z.literal("databuddy"),
   z.literal("posthog"),
   z.literal("sentry"),
   z.undefined(),
@@ -237,16 +239,16 @@ function normalizeEndpointPath(path3) {
 }
 
 // src/shared/once.ts
-function createConsoleOnceLogger(method, warnedKeys6 = /* @__PURE__ */ new Set()) {
+function createConsoleOnceLogger(method, warnedKeys7 = /* @__PURE__ */ new Set()) {
   return (key, message, error) => {
-    if (warnedKeys6.has(key) || typeof console === "undefined") {
+    if (warnedKeys7.has(key) || typeof console === "undefined") {
       return;
     }
     const writer = console[method];
     if (typeof writer !== "function") {
       return;
     }
-    warnedKeys6.add(key);
+    warnedKeys7.add(key);
     if (error === void 0) {
       writer.call(console, message);
       return;
@@ -254,11 +256,11 @@ function createConsoleOnceLogger(method, warnedKeys6 = /* @__PURE__ */ new Set()
     writer.call(console, message, error);
   };
 }
-function createWarnOnceLogger(warnedKeys6) {
-  return createConsoleOnceLogger("warn", warnedKeys6);
+function createWarnOnceLogger(warnedKeys7) {
+  return createConsoleOnceLogger("warn", warnedKeys7);
 }
-function createErrorOnceLogger(warnedKeys6) {
-  return createConsoleOnceLogger("error", warnedKeys6);
+function createErrorOnceLogger(warnedKeys7) {
+  return createConsoleOnceLogger("error", warnedKeys7);
 }
 
 // src/core/config.ts
@@ -624,6 +626,28 @@ function mergePostHogConnectorConfig(base, override) {
     }
   };
 }
+function mergeDatabuddyConnectorConfig(base, override) {
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const apiKey = override?.apiKey ?? base?.apiKey;
+  const websiteId = override?.websiteId ?? base?.websiteId;
+  const ready = enabled && hasNonEmptyString(apiKey) && hasNonEmptyString(websiteId);
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    apiKey,
+    websiteId,
+    namespace: override?.namespace ?? base?.namespace,
+    source: override?.source ?? base?.source,
+    apiUrl: override?.apiUrl ?? base?.apiUrl,
+    debug: override?.debug ?? base?.debug ?? false,
+    enableBatching: override?.enableBatching ?? base?.enableBatching ?? true,
+    batchSize: override?.batchSize ?? base?.batchSize,
+    batchTimeout: override?.batchTimeout ?? base?.batchTimeout,
+    maxQueueSize: override?.maxQueueSize ?? base?.maxQueueSize,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
 function mergeBetterStackConnectorConfig(base, override) {
   const sourceToken = override?.sourceToken ?? base?.sourceToken;
   const ingestingHost = override?.ingestingHost ?? base?.ingestingHost;
@@ -714,6 +738,7 @@ function mergeOTLPConnectorsConfig(base, override) {
 function mergeConnectorsConfig(base, override) {
   return {
     betterstack: mergeBetterStackConnectorConfig(base?.betterstack, override?.betterstack),
+    databuddy: mergeDatabuddyConnectorConfig(base?.databuddy, override?.databuddy),
     posthog: mergePostHogConnectorConfig(base?.posthog, override?.posthog),
     sentry: mergeSentryConnectorConfig(base?.sentry, override?.sentry),
     otlp: mergeOTLPConnectorsConfig(base?.otlp, override?.otlp)
@@ -1830,10 +1855,318 @@ function createBetterStackSender(config) {
     }
   };
 }
-var PREVIOUSLY_CAPTURED_ERROR_KEY2 = "__posthog_previously_captured_error";
 var warnedKeys3 = /* @__PURE__ */ new Set();
+var senderCache = /* @__PURE__ */ new Map();
 var testHooks2 = {};
 var warnOnce4 = createErrorOnceLogger(warnedKeys3);
+function registerShutdownHooks2(key, shutdown) {
+  const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
+  for (const event of handlers) {
+    process.once(event, () => {
+      void shutdown().catch((error) => {
+        warnOnce4(
+          `${key}:shutdown`,
+          "[Blyp] Failed to flush Databuddy telemetry during shutdown.",
+          error
+        );
+      });
+    });
+  }
+}
+function resolveConnectorConfig2(config) {
+  const connector = isBlypConfig(config) ? config.connectors?.databuddy : config;
+  const enabled = connector?.enabled ?? false;
+  const apiKey = connector?.apiKey;
+  const websiteId = connector?.websiteId;
+  const ready = enabled && hasNonEmptyString(apiKey) && hasNonEmptyString(websiteId);
+  return {
+    enabled,
+    mode: connector?.mode ?? "auto",
+    apiKey,
+    websiteId,
+    namespace: connector?.namespace,
+    source: connector?.source,
+    apiUrl: connector?.apiUrl,
+    debug: connector?.debug ?? false,
+    enableBatching: connector?.enableBatching ?? true,
+    batchSize: connector?.batchSize,
+    batchTimeout: connector?.batchTimeout,
+    maxQueueSize: connector?.maxQueueSize,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function createDefaultClient2(connector) {
+  return new Databuddy({
+    apiKey: connector.apiKey ?? "",
+    ...connector.websiteId ? { websiteId: connector.websiteId } : {},
+    ...connector.namespace ? { namespace: connector.namespace } : {},
+    ...connector.source ? { source: connector.source } : {},
+    ...connector.apiUrl ? { apiUrl: connector.apiUrl } : {},
+    debug: connector.debug,
+    enableBatching: connector.enableBatching,
+    ...connector.batchSize !== void 0 ? { batchSize: connector.batchSize } : {},
+    ...connector.batchTimeout !== void 0 ? { batchTimeout: connector.batchTimeout } : {},
+    ...connector.maxQueueSize !== void 0 ? { maxQueueSize: connector.maxQueueSize } : {}
+  });
+}
+function getDatabuddySenderKey(connector) {
+  return JSON.stringify({
+    enabled: connector.enabled,
+    mode: connector.mode,
+    apiKey: connector.apiKey ?? null,
+    websiteId: connector.websiteId ?? null,
+    namespace: connector.namespace ?? null,
+    source: connector.source ?? null,
+    apiUrl: connector.apiUrl ?? null,
+    debug: connector.debug,
+    enableBatching: connector.enableBatching,
+    batchSize: connector.batchSize ?? null,
+    batchTimeout: connector.batchTimeout ?? null,
+    maxQueueSize: connector.maxQueueSize ?? null
+  });
+}
+function getSessionId(record) {
+  const direct = getField(record, "sessionId");
+  if (hasNonEmptyString(direct)) {
+    return direct;
+  }
+  return getClientSessionField(record, "sessionId");
+}
+function getAnonymousId(record) {
+  const direct = getField(record, "anonymousId");
+  if (hasNonEmptyString(direct)) {
+    return direct;
+  }
+  const payload = getPrimaryPayload(record);
+  if (isPlainObject(payload.metadata) && hasNonEmptyString(payload.metadata.databuddyAnonymousId)) {
+    return payload.metadata.databuddyAnonymousId;
+  }
+  return void 0;
+}
+function getDatabuddyEventName(record) {
+  const recordType = getRecordType(record);
+  if (hasNonEmptyString(recordType)) {
+    return recordType;
+  }
+  return "log";
+}
+function buildRecordProperties(record, source) {
+  const properties = {
+    blyp_level: record.level,
+    blyp_source: source,
+    blyp_payload: serializeLogRecord(record),
+    message: typeof record.message === "string" ? record.message : String(record.message)
+  };
+  const caller = typeof record.caller === "string" ? record.caller : void 0;
+  const groupId = getField(record, "groupId");
+  const method = getField(record, "method");
+  const path3 = getField(record, "path");
+  const status = getField(record, "status");
+  const duration = getField(record, "duration");
+  const pagePath = getClientPageField(record, "pathname");
+  const pageUrl = getClientPageField(record, "url");
+  const sessionId = getClientSessionField(record, "sessionId");
+  const pageId = getClientSessionField(record, "pageId");
+  const ifTruthy = [
+    ["blyp_type", getRecordType(record)],
+    ["caller", caller],
+    ["group_id", groupId],
+    ["method", method],
+    ["path", path3],
+    ["page_path", pagePath],
+    ["page_url", pageUrl],
+    ["session_id", sessionId],
+    ["page_id", pageId]
+  ];
+  const ifDefined = [
+    ["status_code", status],
+    ["duration_ms", duration]
+  ];
+  for (const [key, value] of ifTruthy) {
+    if (value) {
+      properties[key] = value;
+    }
+  }
+  for (const [key, value] of ifDefined) {
+    if (value !== void 0) {
+      properties[key] = value;
+    }
+  }
+  return properties;
+}
+function createTrackEvent(record, source) {
+  return {
+    name: getDatabuddyEventName(record),
+    anonymousId: getAnonymousId(record),
+    sessionId: getSessionId(record),
+    properties: buildRecordProperties(record, source)
+  };
+}
+function normalizeExceptionProperties(value) {
+  if (!isPlainObject(value)) {
+    return {};
+  }
+  return normalizeLogValue(value);
+}
+function normalizeExceptionInput2(value, fallbackMessage) {
+  if (value instanceof Error) {
+    return {
+      message: value.message || fallbackMessage,
+      properties: {
+        error_type: value.name,
+        ...value.stack ? { stack: value.stack } : {},
+        ...normalizeExceptionProperties(value)
+      }
+    };
+  }
+  if (isPlainObject(value)) {
+    const message = hasNonEmptyString(value.message) ? value.message : hasNonEmptyString(value.error) ? value.error : fallbackMessage;
+    return {
+      message,
+      properties: normalizeExceptionProperties(value)
+    };
+  }
+  if (typeof value === "string") {
+    return {
+      message: value,
+      properties: {
+        message: value
+      }
+    };
+  }
+  return {
+    message: fallbackMessage,
+    properties: {
+      value: normalizeLogValue(value)
+    }
+  };
+}
+function createDatabuddySender(config) {
+  const connector = resolveConnectorConfig2(config);
+  const senderKey = getDatabuddySenderKey(connector);
+  const cached = senderCache.get(senderKey);
+  if (cached) {
+    return cached;
+  }
+  const key = `${connector.apiUrl ?? "default"}:${connector.mode}:${connector.apiKey ?? "missing"}`;
+  const client = connector.ready ? testHooks2.createClient?.(connector) ?? createDefaultClient2(connector) : void 0;
+  if (client) {
+    registerShutdownHooks2(key, async () => {
+      await client.flush();
+    });
+  }
+  const emitUnavailableWarning = () => {
+    warnOnce4(
+      `databuddy-unavailable:${key}`,
+      "[Blyp] Databuddy connector is not configured. Databuddy requires both apiKey and websiteId. Skipping Databuddy delivery."
+    );
+  };
+  const emitExceptionUnavailableWarning = () => {
+    warnOnce4(
+      `databuddy-exception-unavailable:${key}`,
+      "[Blyp] Databuddy error tracking is not configured. Databuddy requires both apiKey and websiteId. Skipping Databuddy exception capture."
+    );
+  };
+  const sender = {
+    enabled: connector.enabled,
+    ready: connector.ready,
+    mode: connector.mode,
+    status: connector.status,
+    shouldAutoForwardServerLogs() {
+      return connector.ready && connector.mode === "auto";
+    },
+    shouldAutoCaptureExceptions() {
+      return connector.ready && connector.mode === "auto";
+    },
+    send(record, options = {}) {
+      if (!connector.ready || !client) {
+        if (options.warnIfUnavailable) {
+          emitUnavailableWarning();
+        }
+        return;
+      }
+      try {
+        const result = client.track(createTrackEvent(record, options.source ?? "server"));
+        if (result && typeof result.catch === "function") {
+          void result.catch((error) => {
+            warnOnce4(
+              `databuddy-send:${key}`,
+              "[Blyp] Failed to deliver log to Databuddy.",
+              error
+            );
+          });
+        }
+      } catch (error) {
+        warnOnce4(
+          `databuddy-send:${key}`,
+          "[Blyp] Failed to deliver log to Databuddy.",
+          error
+        );
+      }
+    },
+    captureException(error, options = {}) {
+      if (!connector.ready || !client) {
+        if (options.warnIfUnavailable) {
+          emitExceptionUnavailableWarning();
+        }
+        return;
+      }
+      const normalized = normalizeExceptionInput2(
+        error,
+        options.source === "client" ? "Client error" : "Server error"
+      );
+      try {
+        const result = client.track({
+          name: "error",
+          anonymousId: options.anonymousId,
+          sessionId: options.sessionId,
+          properties: {
+            message: normalized.message,
+            blyp_source: options.source ?? "server",
+            blyp_level: "error",
+            ...normalized.properties,
+            ...options.properties ?? {}
+          }
+        });
+        if (result && typeof result.catch === "function") {
+          void result.catch((captureError) => {
+            warnOnce4(
+              `databuddy-capture:${key}`,
+              "[Blyp] Failed to capture exception in Databuddy.",
+              captureError
+            );
+          });
+        }
+      } catch (captureError) {
+        warnOnce4(
+          `databuddy-capture:${key}`,
+          "[Blyp] Failed to capture exception in Databuddy.",
+          captureError
+        );
+      }
+    },
+    async flush() {
+      try {
+        if (client) {
+          await client.flush();
+        }
+      } catch (error) {
+        warnOnce4(
+          `databuddy-flush:${key}`,
+          "[Blyp] Failed to flush Databuddy telemetry.",
+          error
+        );
+      }
+    }
+  };
+  senderCache.set(senderKey, sender);
+  return sender;
+}
+var PREVIOUSLY_CAPTURED_ERROR_KEY2 = "__posthog_previously_captured_error";
+var warnedKeys4 = /* @__PURE__ */ new Set();
+var testHooks3 = {};
+var warnOnce5 = createErrorOnceLogger(warnedKeys4);
 function normalizeHost(host) {
   const trimmed = (host || "https://us.i.posthog.com").trim();
   return trimmed.replace(/\/+$/, "");
@@ -1874,7 +2207,7 @@ function buildRecordAttributes(record, source) {
   for (const [k, v] of ifDefined) if (v !== void 0) attributes[k] = v;
   return attributes;
 }
-function normalizeExceptionProperties(value) {
+function normalizeExceptionProperties2(value) {
   if (!isPlainObject(value)) {
     return {};
   }
@@ -1906,18 +2239,18 @@ function createSyntheticError(message, source) {
   assignExceptionField(error, "details", source.details);
   return error;
 }
-function normalizeExceptionInput2(input, fallbackMessage = "Unknown error") {
+function normalizeExceptionInput3(input, fallbackMessage = "Unknown error") {
   if (input instanceof Error) {
     return {
       error: input,
-      properties: normalizeExceptionProperties(input)
+      properties: normalizeExceptionProperties2(input)
     };
   }
   if (isPlainObject(input)) {
     const message = hasNonEmptyString(input.message) ? input.message : hasNonEmptyString(input.error) ? input.error : fallbackMessage;
     return {
       error: createSyntheticError(message, input),
-      properties: normalizeExceptionProperties(input)
+      properties: normalizeExceptionProperties2(input)
     };
   }
   if (typeof input === "string") {
@@ -1993,12 +2326,12 @@ function resolveSeverity(level) {
       return { text: "info", number: SeverityNumber.INFO };
   }
 }
-function registerShutdownHooks2(key, shutdown) {
+function registerShutdownHooks3(key, shutdown) {
   const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
   for (const event of handlers) {
     process.once(event, () => {
       void shutdown().catch((error) => {
-        warnOnce4(
+        warnOnce5(
           `${key}:shutdown`,
           "[Blyp] Failed to flush PostHog telemetry during shutdown.",
           error
@@ -2052,7 +2385,7 @@ function createDefaultExceptionClient(connector) {
     }
   };
 }
-function resolveConnectorConfig2(config) {
+function resolveConnectorConfig3(config) {
   const connector = isBlypConfig(config) ? config.connectors?.posthog : config;
   const enabled = connector?.enabled ?? false;
   const projectKey = connector?.projectKey;
@@ -2075,11 +2408,11 @@ function resolveConnectorConfig2(config) {
   };
 }
 function createPostHogSender(config) {
-  const connector = resolveConnectorConfig2(config);
+  const connector = resolveConnectorConfig3(config);
   const key = `${connector.serviceName}:${connector.host}:${connector.mode}`;
   const ready = connector.enabled === true && hasNonEmptyString(connector.projectKey);
-  const transport = ready ? testHooks2.createTransport?.(connector) ?? createDefaultTransport(connector) : void 0;
-  const exceptionClient = connector.errorTracking.ready ? testHooks2.createExceptionClient?.(connector) ?? createDefaultExceptionClient(connector) : void 0;
+  const transport = ready ? testHooks3.createTransport?.(connector) ?? createDefaultTransport(connector) : void 0;
+  const exceptionClient = connector.errorTracking.ready ? testHooks3.createExceptionClient?.(connector) ?? createDefaultExceptionClient(connector) : void 0;
   const shutdown = async () => {
     if (transport?.shutdown) {
       await transport.shutdown();
@@ -2091,16 +2424,16 @@ function createPostHogSender(config) {
     }
   };
   if (transport || exceptionClient) {
-    registerShutdownHooks2(key, shutdown);
+    registerShutdownHooks3(key, shutdown);
   }
   const emitUnavailableWarning = () => {
-    warnOnce4(
+    warnOnce5(
       `posthog-unavailable:${key}`,
       "[Blyp] PostHog connector is not configured. Skipping PostHog delivery."
     );
   };
   const emitExceptionUnavailableWarning = () => {
-    warnOnce4(
+    warnOnce5(
       `posthog-exception-unavailable:${key}`,
       "[Blyp] PostHog error tracking is not configured. Skipping PostHog exception capture."
     );
@@ -2138,7 +2471,7 @@ function createPostHogSender(config) {
         const result = transport.emit(normalized);
         if (result && typeof result.catch === "function") {
           void result.catch((error) => {
-            warnOnce4(
+            warnOnce5(
               `posthog-emit:${key}`,
               "[Blyp] Failed to deliver log to PostHog.",
               error
@@ -2146,7 +2479,7 @@ function createPostHogSender(config) {
           });
         }
       } catch (error) {
-        warnOnce4(
+        warnOnce5(
           `posthog-emit:${key}`,
           "[Blyp] Failed to deliver log to PostHog.",
           error
@@ -2163,7 +2496,7 @@ function createPostHogSender(config) {
       if (isPreviouslyCapturedPostHogError(error)) {
         return;
       }
-      const normalized = normalizeExceptionInput2(
+      const normalized = normalizeExceptionInput3(
         error,
         options.source === "client" ? "Client error" : "Server error"
       );
@@ -2182,7 +2515,7 @@ function createPostHogSender(config) {
         markPostHogCapturedError(normalized.error);
         if (result && typeof result.catch === "function") {
           void result.catch((captureError) => {
-            warnOnce4(
+            warnOnce5(
               `posthog-capture:${key}`,
               "[Blyp] Failed to capture exception in PostHog.",
               captureError
@@ -2190,7 +2523,7 @@ function createPostHogSender(config) {
           });
         }
       } catch (captureError) {
-        warnOnce4(
+        warnOnce5(
           `posthog-capture:${key}`,
           "[Blyp] Failed to capture exception in PostHog.",
           captureError
@@ -2203,7 +2536,7 @@ function createPostHogSender(config) {
           await transport.flush();
         }
       } catch (error) {
-        warnOnce4(
+        warnOnce5(
           `posthog-flush:${key}`,
           "[Blyp] Failed to flush PostHog telemetry.",
           error
@@ -2218,13 +2551,13 @@ function buildPostHogExceptionProperties(record, source, properties = {}) {
     ...properties
   };
 }
-var warnedKeys4 = /* @__PURE__ */ new Set();
-var testHooks3 = {};
-var warnOnce5 = createErrorOnceLogger(warnedKeys4);
+var warnedKeys5 = /* @__PURE__ */ new Set();
+var testHooks4 = {};
+var warnOnce6 = createErrorOnceLogger(warnedKeys5);
 function getSentryModule2() {
-  return testHooks3.module ?? Sentry;
+  return testHooks4.module ?? Sentry;
 }
-function resolveConnectorConfig3(config) {
+function resolveConnectorConfig4(config) {
   const connector = isBlypConfig(config) ? config.connectors?.sentry : config;
   const enabled = connector?.enabled ?? false;
   const dsn = connector?.dsn;
@@ -2369,7 +2702,7 @@ function hasConfigMismatch(connector, client) {
   return hasNonEmptyString(connector.dsn) && connector.dsn !== options.dsn || hasNonEmptyString(connector.environment) && connector.environment !== options.environment || hasNonEmptyString(connector.release) && connector.release !== options.release;
 }
 function createSentrySender(config) {
-  const connector = resolveConnectorConfig3(config);
+  const connector = resolveConnectorConfig4(config);
   const key = `${connector.mode}:${connector.dsn ?? "missing"}`;
   const module = getSentryModule2();
   let client = connector.enabled ? module.getClient() : void 0;
@@ -2383,7 +2716,7 @@ function createSentrySender(config) {
       });
       client = module.getClient();
     } catch (error) {
-      warnOnce5(
+      warnOnce6(
         `sentry-init:${key}`,
         "[Blyp] Failed to initialize Sentry. Skipping Sentry delivery.",
         error
@@ -2391,14 +2724,14 @@ function createSentrySender(config) {
     }
   }
   if (client && hasConfigMismatch(connector, client)) {
-    warnOnce5(
+    warnOnce6(
       `sentry-mismatch:${key}`,
       "[Blyp] Sentry is already initialized with different options. Reusing the existing Sentry client."
     );
   }
   const ready = connector.enabled && client !== void 0;
   const emitUnavailableWarning = () => {
-    warnOnce5(
+    warnOnce6(
       `sentry-unavailable:${key}`,
       "[Blyp] Sentry connector is not configured. Skipping Sentry delivery."
     );
@@ -2424,7 +2757,7 @@ function createSentrySender(config) {
       try {
         logMethod(record.message, attributes);
       } catch (error) {
-        warnOnce5(
+        warnOnce6(
           `sentry-log:${key}`,
           "[Blyp] Failed to deliver log to Sentry.",
           error
@@ -2442,7 +2775,7 @@ function createSentrySender(config) {
           module.captureException(exception);
         });
       } catch (error) {
-        warnOnce5(
+        warnOnce6(
           `sentry-exception:${key}`,
           "[Blyp] Failed to capture exception in Sentry.",
           error
@@ -2453,7 +2786,7 @@ function createSentrySender(config) {
       try {
         await module.flush(2e3);
       } catch (error) {
-        warnOnce5(
+        warnOnce6(
           `sentry-flush:${key}`,
           "[Blyp] Failed to flush Sentry logs.",
           error
@@ -2462,9 +2795,9 @@ function createSentrySender(config) {
     }
   };
 }
-var warnedKeys5 = /* @__PURE__ */ new Set();
-var testHooks4 = {};
-var warnOnce6 = createErrorOnceLogger(warnedKeys5);
+var warnedKeys6 = /* @__PURE__ */ new Set();
+var testHooks5 = {};
+var warnOnce7 = createErrorOnceLogger(warnedKeys6);
 function normalizeOTLPRecord(record, connector, source = "server") {
   const severity = resolveSeverity2(record.level);
   const body = typeof record.message === "string" ? record.message : String(record.message);
@@ -2529,14 +2862,14 @@ function resolveSeverity2(level) {
       return { text: "info", number: SeverityNumber.INFO };
   }
 }
-function registerShutdownHooks3(key, shutdown) {
+function registerShutdownHooks4(key, shutdown) {
   const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
   for (const event of handlers) {
     process.once(event, async () => {
       try {
         await shutdown();
       } catch (error) {
-        warnOnce6(
+        warnOnce7(
           `${key}:shutdown`,
           "[Blyp] Failed to flush OTLP logs during shutdown.",
           error
@@ -2613,7 +2946,7 @@ function createUnavailableSender(name, connector) {
   const senderName = name || connector?.name || "otlp";
   const key = `${senderName}:${connector?.serviceName ?? "blyp-app"}:${connector?.endpoint ?? "missing"}`;
   const emitUnavailableWarning = () => {
-    warnOnce6(
+    warnOnce7(
       `otlp-unavailable:${key}`,
       `[Blyp] OTLP target "${senderName}" is not configured or not ready. Skipping OTLP delivery.`
     );
@@ -2644,7 +2977,7 @@ function createSender(connector) {
     ...connector,
     headers: resolveTransportHeaders(connector)
   };
-  const transport = testHooks4.createTransport?.(transportConnector) ?? createDefaultTransport2(transportConnector);
+  const transport = testHooks5.createTransport?.(transportConnector) ?? createDefaultTransport2(transportConnector);
   return {
     name: connector.name,
     enabled: connector.enabled,
@@ -2660,7 +2993,7 @@ function createSender(connector) {
         const result = transport.emit(normalized);
         if (result && typeof result.catch === "function") {
           void result.catch((error) => {
-            warnOnce6(
+            warnOnce7(
               `otlp-emit:${key}`,
               `[Blyp] Failed to deliver log to OTLP target "${connector.name}".`,
               error
@@ -2668,7 +3001,7 @@ function createSender(connector) {
           });
         }
       } catch (error) {
-        warnOnce6(
+        warnOnce7(
           `otlp-emit:${key}`,
           `[Blyp] Failed to deliver log to OTLP target "${connector.name}".`,
           error
@@ -2681,7 +3014,7 @@ function createSender(connector) {
           await transport.flush();
         }
       } catch (error) {
-        warnOnce6(
+        warnOnce7(
           `otlp-flush:${key}`,
           `[Blyp] Failed to flush OTLP logs for target "${connector.name}".`,
           error
@@ -2710,7 +3043,7 @@ function createOTLPRegistry(config) {
       await Promise.all(Array.from(senders.values()).map((sender) => sender.flush()));
     }
   };
-  registerShutdownHooks3("otlp-registry", () => registry.flush());
+  registerShutdownHooks4("otlp-registry", () => registry.flush());
   return registry;
 }
 var _RuntimeDetector = class _RuntimeDetector {
@@ -3108,6 +3441,9 @@ function getPostHogSender(logger3) {
 function getBetterStackSender(logger3) {
   return getLoggerFactory(logger3).betterstack;
 }
+function getDatabuddySender(logger3) {
+  return getLoggerFactory(logger3).databuddy;
+}
 function tryGetPostHogSender(logger3) {
   try {
     return getPostHogSender(logger3);
@@ -3122,6 +3458,13 @@ function tryGetBetterStackSender(logger3) {
     return null;
   }
 }
+function tryGetDatabuddySender(logger3) {
+  try {
+    return getDatabuddySender(logger3);
+  } catch {
+    return null;
+  }
+}
 function getSentrySender(logger3) {
   return getLoggerFactory(logger3).sentry;
 }
@@ -3181,6 +3524,18 @@ function maybeSendToBetterStack(betterstack, record) {
   }
   betterstack.send(record, { source: "server", warnIfUnavailable: true });
 }
+function maybeSendToDatabuddy(databuddy, record) {
+  if (isClientLogRecord(record)) {
+    return;
+  }
+  if (!databuddy.shouldAutoForwardServerLogs()) {
+    if (databuddy.enabled && !databuddy.ready) {
+      databuddy.send(record, { source: "server", warnIfUnavailable: true });
+    }
+    return;
+  }
+  databuddy.send(record, { source: "server", warnIfUnavailable: true });
+}
 function maybeSendToSentry(sentry, record) {
   if (isClientLogRecord(record)) {
     return;
@@ -3201,7 +3556,7 @@ function maybeSendToOTLP(otlp, record) {
     sender.send(record, { source: "server", warnIfUnavailable: true });
   }
 }
-function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry, otlp, bindings = {}, source = "root") {
+function createLoggerInstance(rootRawLogger, sink, betterstack, databuddy, posthog, sentry, otlp, bindings = {}, source = "root") {
   const rawLogger = Object.keys(bindings).length > 0 ? rootRawLogger.child(bindings) : rootRawLogger;
   const writeRecord = (level, message, args, writeSource = source) => {
     if (writeSource === "root" && shouldDropRootLogWrite()) {
@@ -3227,6 +3582,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
     );
     sink.write(record);
     maybeSendToBetterStack(betterstack, record);
+    maybeSendToDatabuddy(databuddy, record);
     maybeSendToPostHog(posthog, record);
     maybeSendToSentry(sentry, record);
     maybeSendToOTLP(otlp, record);
@@ -3250,6 +3606,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
       sink.write(record);
     }
     maybeSendToBetterStack(betterstack, record);
+    maybeSendToDatabuddy(databuddy, record);
     maybeSendToPostHog(posthog, record);
     maybeSendToSentry(sentry, record);
     maybeSendToOTLP(otlp, record);
@@ -3283,8 +3640,26 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
       }
       writeRecord("table", message, data === void 0 ? [] : [data]);
     },
-    flush: () => sink.flush(),
-    shutdown: () => sink.shutdown(),
+    flush: async () => {
+      await sink.flush();
+      await Promise.allSettled([
+        betterstack.flush(),
+        databuddy.flush(),
+        posthog.flush(),
+        sentry.flush(),
+        otlp.flush()
+      ]);
+    },
+    shutdown: async () => {
+      await sink.shutdown();
+      await Promise.allSettled([
+        betterstack.flush(),
+        databuddy.flush(),
+        posthog.flush(),
+        sentry.flush(),
+        otlp.flush()
+      ]);
+    },
     createStructuredLog: (groupId, initial) => {
       return createStructuredLogForLogger(logger3, groupId, {
         initialFields: initial
@@ -3296,6 +3671,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
         rootRawLogger,
         sink,
         betterstack,
+        databuddy,
         posthog,
         sentry,
         otlp,
@@ -3306,6 +3682,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
     [LOGGER_FACTORY]: {
       bindings,
       betterstack,
+      databuddy,
       posthog,
       sentry,
       otlp,
@@ -3315,6 +3692,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
           rootRawLogger,
           sink,
           betterstack,
+          databuddy,
           posthog,
           sentry,
           otlp,
@@ -3338,6 +3716,7 @@ function createBaseLogger(config) {
   const rawLogger = createPinoLogger(resolvedConfig);
   const sink = createPrimarySink(resolvedConfig);
   const betterstack = createBetterStackSender(resolvedConfig);
+  const databuddy = createDatabuddySender(resolvedConfig);
   const posthog = createPostHogSender(resolvedConfig);
   const sentry = createSentrySender(resolvedConfig);
   const otlp = createOTLPRegistry(resolvedConfig);
@@ -3345,6 +3724,7 @@ function createBaseLogger(config) {
     rawLogger,
     sink,
     betterstack,
+    databuddy,
     posthog,
     sentry,
     otlp
@@ -3960,11 +4340,28 @@ function createError(input) {
         }
       });
     }
-  }
-  return error;
-}
-var HTTP_CODES2 = buildHttpCodeRegistry((definition, overrides = {}) => {
-  return createError({
+    const databuddy = tryGetDatabuddySender(input.logger ?? logger);
+    if (databuddy?.shouldAutoCaptureExceptions()) {
+      databuddy.captureException(error, {
+        source: "server",
+        warnIfUnavailable: true,
+        properties: {
+          blyp_type: "application_error",
+          status: error.status,
+          status_code: error.statusCode,
+          ...error.code !== void 0 ? { code: error.code } : {},
+          ...error.why !== void 0 ? { why: error.why } : {},
+          ...error.fix !== void 0 ? { fix: error.fix } : {},
+          ...error.link !== void 0 ? { link: error.link } : {},
+          ...error.details !== void 0 ? { details: error.details } : {}
+        }
+      });
+    }
+  }
+  return error;
+}
+var HTTP_CODES2 = buildHttpCodeRegistry((definition, overrides = {}) => {
+  return createError({
     status: definition.status,
     message: definition.message,
     code: definition.code,
@@ -4344,8 +4741,132 @@ function createStructuredBetterStackLogger(groupId, initial, config = {}) {
   });
 }
 
-// src/connectors/posthog/index.ts
+// src/connectors/databuddy/index.ts
 function resolveSender2(config = {}) {
+  return createDatabuddySender(resolveConfig({
+    ...config.connectors ? { connectors: config.connectors } : {}
+  }));
+}
+function createDatabuddyLoggerInstance(sender, bindings = {}) {
+  const writeRecord = (level, message, args) => {
+    sender.send(buildRecord(level, message, args, bindings), {
+      source: "server",
+      warnIfUnavailable: true
+    });
+  };
+  const writeStructured = (payload, message) => {
+    sender.send(
+      buildStructuredRecord(
+        resolveStructuredWriteLevel(payload.level),
+        message,
+        payload,
+        bindings
+      ),
+      {
+        source: "server",
+        warnIfUnavailable: true
+      }
+    );
+  };
+  return {
+    debug: (message, ...args) => {
+      writeRecord("debug", message, args);
+    },
+    info: (message, ...args) => {
+      writeRecord("info", message, args);
+    },
+    error: (message, ...args) => {
+      writeRecord("error", message, args);
+    },
+    warn: (message, ...args) => {
+      writeRecord("warn", message, args);
+    },
+    warning: (message, ...args) => {
+      writeRecord("warning", message, args);
+    },
+    success: (message, ...args) => {
+      writeRecord("success", message, args);
+    },
+    critical: (message, ...args) => {
+      writeRecord("critical", message, args);
+    },
+    table: (message, data) => {
+      writeRecord("table", message, data === void 0 ? [] : [data]);
+    },
+    flush: async () => {
+      await sender.flush();
+    },
+    shutdown: async () => {
+      await sender.flush();
+    },
+    createStructuredLog: (groupId, initial) => {
+      return createStructuredLog(groupId, {
+        initialFields: initial,
+        write: writeStructured
+      });
+    },
+    child: (childBindings) => {
+      return createDatabuddyLoggerInstance(sender, {
+        ...bindings,
+        ...childBindings
+      });
+    }
+  };
+}
+function createDatabuddyErrorTrackerInstance(sender, bindings = {}) {
+  return {
+    capture: (error, options = {}) => {
+      sender.captureException(error, {
+        source: "server",
+        warnIfUnavailable: true,
+        properties: {
+          ...bindings,
+          ...options.properties ?? {},
+          blyp_source: "server",
+          blyp_manual: true
+        }
+      });
+    },
+    child: (childBindings) => {
+      return createDatabuddyErrorTrackerInstance(sender, {
+        ...bindings,
+        ...childBindings
+      });
+    }
+  };
+}
+function createDatabuddyLogger(config = {}) {
+  return createDatabuddyLoggerInstance(resolveSender2(config));
+}
+function createStructuredDatabuddyLogger(groupId, initial, config = {}) {
+  const sender = resolveSender2(config);
+  return createStructuredLog(groupId, {
+    initialFields: initial,
+    write: (payload, message) => {
+      sender.send(
+        buildStructuredRecord(
+          resolveStructuredWriteLevel(payload.level),
+          message,
+          payload,
+          {}
+        ),
+        {
+          source: "server",
+          warnIfUnavailable: true
+        }
+      );
+    }
+  });
+}
+function createDatabuddyErrorTracker(config = {}) {
+  return createDatabuddyErrorTrackerInstance(resolveSender2(config));
+}
+function captureDatabuddyException(error, options = {}, config = {}) {
+  createDatabuddyErrorTracker(config).capture(error, options);
+}
+
+// src/connectors/posthog/index.ts
+function resolveSender3(config = {}) {
   return createPostHogSender(resolveConfig({
     ...config.connectors ? { connectors: config.connectors } : {}
   }));
@@ -4438,10 +4959,10 @@ function createPostHogErrorTrackerInstance(sender, bindings = {}) {
   };
 }
 function createPosthogLogger(config = {}) {
-  return createPostHogLoggerInstance(resolveSender2(config));
+  return createPostHogLoggerInstance(resolveSender3(config));
 }
 function createStructuredPosthogLogger(groupId, initial, config = {}) {
-  const sender = resolveSender2(config);
+  const sender = resolveSender3(config);
   return createStructuredLog(groupId, {
     initialFields: initial,
     write: (payload, message) => {
@@ -4461,14 +4982,14 @@ function createStructuredPosthogLogger(groupId, initial, config = {}) {
   });
 }
 function createPosthogErrorTracker(config = {}) {
-  return createPostHogErrorTrackerInstance(resolveSender2(config));
+  return createPostHogErrorTrackerInstance(resolveSender3(config));
 }
 function capturePosthogException(error, options = {}, config = {}) {
   createPosthogErrorTracker(config).capture(error, options);
 }
 
 // src/connectors/sentry/index.ts
-function resolveSender3(config = {}) {
+function resolveSender4(config = {}) {
   return createSentrySender(resolveConfig({
     ...config.connectors ? { connectors: config.connectors } : {}
   }));
@@ -4538,10 +5059,10 @@ function createSentryLoggerInstance(sender, bindings = {}) {
   };
 }
 function createSentryLogger(config = {}) {
-  return createSentryLoggerInstance(resolveSender3(config));
+  return createSentryLoggerInstance(resolveSender4(config));
 }
 function createStructuredSentryLogger(groupId, initial, config = {}) {
-  const sender = resolveSender3(config);
+  const sender = resolveSender4(config);
   return createStructuredLog(groupId, {
     initialFields: initial,
     write: (payload, message) => {
@@ -4836,6 +5357,7 @@ function resolveServerLogger(config = {}, loggerOverride) {
   return {
     logger: logger3,
     betterstack: getBetterStackSender(logger3),
+    databuddy: getDatabuddySender(logger3),
     posthog: getPostHogSender(logger3),
     sentry: getSentrySender(logger3),
     otlp: getOtlpRegistry(logger3),
@@ -4955,6 +5477,22 @@ function emitHttpErrorLog(logger3, level, request, path3, statusCode, responseTi
       }
     });
   }
+  const databuddy = tryGetDatabuddySender(logger3);
+  if (databuddy?.shouldAutoCaptureExceptions()) {
+    databuddy.captureException(captureContext.error ?? error ?? message, {
+      source: "server",
+      warnIfUnavailable: true,
+      properties: {
+        method: request.method,
+        path: path3,
+        status_code: statusCode,
+        ...request.url ? { current_url: request.url } : {},
+        ...getHeaderValue(request.headers, "user-agent") ? { user_agent: getHeaderValue(request.headers, "user-agent") } : {},
+        ...errorLogData.ip ? { ip: errorLogData.ip } : {},
+        payload: errorLogData
+      }
+    });
+  }
   return errorLogData;
 }
 async function parseClientLogPayload(request, body) {
@@ -5046,6 +5584,34 @@ async function handleClientLogIngestion(options) {
         });
       }
     }
+  } else if (payload.connector === "databuddy") {
+    headers["x-blyp-databuddy-status"] = config.databuddy.ready ? "enabled" : "missing";
+    if (config.databuddy.ready) {
+      const forwardedRecord = {
+        timestamp: structuredPayload.receivedAt,
+        level: payload.level,
+        message: `[client] ${payload.message}`,
+        data: structuredPayload
+      };
+      config.databuddy.send(forwardedRecord, {
+        source: "client"
+      });
+      if ((payload.level === "error" || payload.level === "critical") && config.databuddy.shouldAutoCaptureExceptions()) {
+        const clientErrorCandidate = payload.data && typeof payload.data === "object" && !Array.isArray(payload.data) && typeof payload.data.message === "string" ? payload.data : payload.message;
+        config.databuddy.captureException(clientErrorCandidate, {
+          source: "client",
+          warnIfUnavailable: true,
+          sessionId: payload.session.sessionId,
+          properties: {
+            page_url: payload.page.url,
+            page_path: payload.page.pathname,
+            client_runtime: payload.device?.runtime,
+            metadata: payload.metadata,
+            payload: structuredPayload
+          }
+        });
+      }
+    }
   } else if (payload.connector === "posthog") {
     headers["x-blyp-posthog-status"] = config.posthog.ready ? "enabled" : "missing";
     if (config.posthog.ready) {
@@ -5712,8 +6278,160 @@ function createNextJsLogger(config = {}) {
   };
 }
 
+// src/frameworks/react-router/logger.ts
+var REACT_ROUTER_LOGGER_KEY = /* @__PURE__ */ Symbol.for("blyp.react-router.logger");
+var REACT_ROUTER_LOGGER_FALLBACK_KEY = "__blypLog";
+function createContext2(args, response, error) {
+  return {
+    request: args.request,
+    params: args.params,
+    context: args.context,
+    response,
+    error
+  };
+}
+function readLoggerValue(context) {
+  if (typeof context.get === "function") {
+    const symbolValue = context.get(REACT_ROUTER_LOGGER_KEY);
+    if (symbolValue) {
+      return symbolValue;
+    }
+    return context.get(REACT_ROUTER_LOGGER_FALLBACK_KEY);
+  }
+  return context[REACT_ROUTER_LOGGER_KEY] ?? context[REACT_ROUTER_LOGGER_FALLBACK_KEY];
+}
+function writeLoggerValue(context, logger3) {
+  if (typeof context.set === "function") {
+    context.set(REACT_ROUTER_LOGGER_KEY, logger3);
+    context.set(REACT_ROUTER_LOGGER_FALLBACK_KEY, logger3);
+    return;
+  }
+  context[REACT_ROUTER_LOGGER_KEY] = logger3;
+  context[REACT_ROUTER_LOGGER_FALLBACK_KEY] = logger3;
+}
+function resolveThrownStatusCode(error) {
+  const errorLike = toErrorLike(error);
+  return errorLike?.status ?? errorLike?.statusCode ?? 500;
+}
+function createReactRouterLogger(config = {}) {
+  const shared = resolveServerLogger(config);
+  const setLogger = (context, logger3) => {
+    writeLoggerValue(context, logger3);
+  };
+  const getLogger = (context) => {
+    const logger3 = readLoggerValue(context);
+    return logger3 && typeof logger3 === "object" ? logger3 : shared.logger;
+  };
+  return {
+    logger: shared.logger,
+    setLogger,
+    getLogger,
+    middleware: async (args, next) => {
+      return runWithRequestContext(async () => {
+        const startTime = performance.now();
+        const path3 = extractPathname(args.request.url);
+        let structuredLogEmitted = false;
+        const scopedLogger = createRequestScopedLogger(shared.logger, {
+          resolveStructuredFields: () => ({
+            method: args.request.method,
+            path: path3,
+            ...resolveAdditionalProps(shared, createContext2(args))
+          }),
+          onStructuredEmit: () => {
+            structuredLogEmitted = true;
+          }
+        });
+        setLogger(args.context, scopedLogger);
+        try {
+          const response = await next();
+          if (structuredLogEmitted) {
+            await flushServerLoggerSafely(shared);
+            return response;
+          }
+          const statusCode = response.status;
+          const loggerContext = createContext2(args, response);
+          const responseTime = Math.round(performance.now() - startTime);
+          const requestLike = createRequestLike(
+            args.request.method,
+            args.request.url,
+            args.request.headers
+          );
+          if (isErrorStatus(statusCode)) {
+            if (!shouldSkipErrorLogging(shared, path3)) {
+              emitHttpErrorLog(
+                shared.logger,
+                shared.level,
+                requestLike,
+                path3,
+                statusCode,
+                responseTime,
+                toErrorLike(void 0, statusCode),
+                resolveAdditionalProps(shared, loggerContext)
+              );
+            }
+          } else if (!shouldSkipAutoLogging(shared, loggerContext, path3)) {
+            emitHttpRequestLog(
+              shared.logger,
+              shared.level,
+              requestLike,
+              path3,
+              statusCode,
+              responseTime,
+              resolveAdditionalProps(shared, loggerContext)
+            );
+          }
+          await flushServerLoggerSafely(shared);
+          return response;
+        } catch (error) {
+          if (!structuredLogEmitted && !shouldSkipErrorLogging(shared, path3)) {
+            const statusCode = resolveThrownStatusCode(error);
+            emitHttpErrorLog(
+              shared.logger,
+              shared.level,
+              createRequestLike(args.request.method, args.request.url, args.request.headers),
+              path3,
+              statusCode,
+              Math.round(performance.now() - startTime),
+              toErrorLike(error, statusCode),
+              resolveAdditionalProps(shared, createContext2(args, void 0, error)),
+              { error }
+            );
+          }
+          await flushServerLoggerSafely(shared);
+          throw error;
+        }
+      });
+    },
+    clientLogHandler: async (request) => {
+      const path3 = extractPathname(request.url);
+      if (path3 !== shared.ingestionPath) {
+        return new Response(
+          JSON.stringify({
+            error: `Mounted route path ${path3} does not match configured client logging path ${shared.ingestionPath}`
+          }),
+          {
+            status: 500,
+            headers: { "content-type": "application/json" }
+          }
+        );
+      }
+      const result = await handleClientLogIngestion({
+        config: shared,
+        ctx: createContext2({ request, context: {} }),
+        request,
+        deliveryPath: path3
+      });
+      await flushServerLoggerSafely(shared);
+      return new Response(null, {
+        status: result.status,
+        headers: result.headers
+      });
+    }
+  };
+}
+
 // src/frameworks/tanstack-start/logger.ts
-function createContext2(request, context, response, error) {
+function createContext3(request, context, response, error) {
   return { request, context, response, error };
 }
 function createTanStackStartLogger(config = {}) {
@@ -5732,7 +6450,7 @@ function createTanStackStartLogger(config = {}) {
           resolveStructuredFields: () => ({
             method: request.method,
             path: path3,
-            ...resolveAdditionalProps(shared, createContext2(request, nextContext))
+            ...resolveAdditionalProps(shared, createContext3(request, nextContext))
           }),
           onStructuredEmit: () => {
             structuredLogEmitted = true;
@@ -5746,7 +6464,7 @@ function createTanStackStartLogger(config = {}) {
             return response;
           }
           const statusCode = response.status;
-          const loggerContext = createContext2(request, nextContext, response);
+          const loggerContext = createContext3(request, nextContext, response);
           const responseTime = Math.round(performance.now() - startTime);
           if (isErrorStatus(statusCode)) {
             if (!shouldSkipErrorLogging(shared, path3)) {
@@ -5784,7 +6502,7 @@ function createTanStackStartLogger(config = {}) {
               500,
               Math.round(performance.now() - startTime),
               toErrorLike(error, 500),
-              resolveAdditionalProps(shared, createContext2(request, nextContext, void 0, error)),
+              resolveAdditionalProps(shared, createContext3(request, nextContext, void 0, error)),
               {
                 error
               }
@@ -5813,7 +6531,7 @@ function createTanStackStartLogger(config = {}) {
         }
         const result = await handleClientLogIngestion({
           config: shared,
-          ctx: createContext2(request, {}),
+          ctx: createContext3(request, {}),
           request,
           deliveryPath: path3
         });
@@ -5828,7 +6546,7 @@ function createTanStackStartLogger(config = {}) {
 }
 
 // src/frameworks/sveltekit/logger.ts
-function createContext3(event, response, error) {
+function createContext4(event, response, error) {
   return { event, response, error };
 }
 function createSvelteKitLogger(config = {}) {
@@ -5840,7 +6558,7 @@ function createSvelteKitLogger(config = {}) {
         resolveStructuredFields: () => ({
           method: event.request.method,
           path: event.url.pathname,
-          ...resolveAdditionalProps(shared, createContext3(event))
+          ...resolveAdditionalProps(shared, createContext4(event))
         }),
         onStructuredEmit: () => {
           structuredLogEmitted = true;
@@ -5860,7 +6578,7 @@ function createSvelteKitLogger(config = {}) {
           return response;
         }
         const statusCode = response.status;
-        const loggerContext = createContext3(event, response);
+        const loggerContext = createContext4(event, response);
         const responseTime = Math.round(performance.now() - startTime);
         if (isErrorStatus(statusCode)) {
           if (!shouldSkipErrorLogging(shared, path3)) {
@@ -5898,7 +6616,7 @@ function createSvelteKitLogger(config = {}) {
             500,
             Math.round(performance.now() - startTime),
             toErrorLike(error, 500),
-            resolveAdditionalProps(shared, createContext3(event, void 0, error)),
+            resolveAdditionalProps(shared, createContext4(event, void 0, error)),
             {
               error
             }
@@ -5929,7 +6647,7 @@ function createSvelteKitLogger(config = {}) {
       }
       const result = await handleClientLogIngestion({
         config: shared,
-        ctx: createContext3(event),
+        ctx: createContext4(event),
         request: event.request,
         deliveryPath: path3
       });
@@ -5942,6 +6660,344 @@ function createSvelteKitLogger(config = {}) {
   };
 }
 
+// src/frameworks/astro/logger.ts
+function createContext5(context, response, error) {
+  return { context, response, error };
+}
+function createAstroLogger(config = {}) {
+  const shared = resolveServerLogger(config);
+  return {
+    logger: shared.logger,
+    onRequest: async (context, next) => {
+      return runWithRequestContext(async () => {
+        let structuredLogEmitted = false;
+        context.locals.blypLog = createRequestScopedLogger(shared.logger, {
+          resolveStructuredFields: () => ({
+            method: context.request.method,
+            path: context.url.pathname,
+            ...resolveAdditionalProps(shared, createContext5(context))
+          }),
+          onStructuredEmit: () => {
+            structuredLogEmitted = true;
+          }
+        });
+        const startTime = performance.now();
+        const path3 = context.url.pathname;
+        const requestLike = createRequestLike(
+          context.request.method,
+          context.request.url,
+          context.request.headers
+        );
+        try {
+          const response = await next();
+          if (structuredLogEmitted) {
+            await flushServerLoggerSafely(shared);
+            return response;
+          }
+          const statusCode = response.status;
+          const loggerContext = createContext5(context, response);
+          const responseTime = Math.round(performance.now() - startTime);
+          if (isErrorStatus(statusCode)) {
+            if (!shouldSkipErrorLogging(shared, path3)) {
+              emitHttpErrorLog(
+                shared.logger,
+                shared.level,
+                requestLike,
+                path3,
+                statusCode,
+                responseTime,
+                toErrorLike(void 0, statusCode),
+                resolveAdditionalProps(shared, loggerContext)
+              );
+            }
+          } else if (!shouldSkipAutoLogging(shared, loggerContext, path3)) {
+            emitHttpRequestLog(
+              shared.logger,
+              shared.level,
+              requestLike,
+              path3,
+              statusCode,
+              responseTime,
+              resolveAdditionalProps(shared, loggerContext)
+            );
+          }
+          await flushServerLoggerSafely(shared);
+          return response;
+        } catch (error) {
+          if (!structuredLogEmitted && !shouldSkipErrorLogging(shared, path3)) {
+            emitHttpErrorLog(
+              shared.logger,
+              shared.level,
+              requestLike,
+              path3,
+              500,
+              Math.round(performance.now() - startTime),
+              toErrorLike(error, 500),
+              resolveAdditionalProps(shared, createContext5(context, void 0, error)),
+              { error }
+            );
+          }
+          await flushServerLoggerSafely(shared);
+          throw error;
+        }
+      });
+    },
+    clientLogHandler: async (context) => {
+      const path3 = context.url.pathname;
+      if (path3 !== shared.ingestionPath) {
+        return new Response(
+          JSON.stringify({
+            error: `Mounted route path ${path3} does not match configured client logging path ${shared.ingestionPath}`
+          }),
+          {
+            status: 500,
+            headers: { "content-type": "application/json" }
+          }
+        );
+      }
+      const result = await handleClientLogIngestion({
+        config: shared,
+        ctx: createContext5(context),
+        request: context.request,
+        deliveryPath: path3
+      });
+      await flushServerLoggerSafely(shared);
+      return new Response(null, {
+        status: result.status,
+        headers: result.headers
+      });
+    }
+  };
+}
+
+// src/frameworks/shared/h3.ts
+var BLYP_NITRO_STATE_KEY = /* @__PURE__ */ Symbol.for("blyp.nitro.state");
+function getNitroState(event) {
+  return event.context[BLYP_NITRO_STATE_KEY];
+}
+function setNitroState(event, state) {
+  event.context[BLYP_NITRO_STATE_KEY] = state;
+  return state;
+}
+function getNitroMethod(event) {
+  return event.method ?? event.node?.req?.method ?? event.request?.method ?? "GET";
+}
+function getNitroHeaders(event) {
+  return event.headers ?? event.node?.req?.headers ?? event.request?.headers;
+}
+function getNitroUrl(event) {
+  if (event.request?.url) {
+    return event.request.url;
+  }
+  const path3 = event.url ?? event.path ?? event.node?.req?.url ?? "/";
+  return buildAbsoluteUrl(path3, getNitroHeaders(event));
+}
+function getNitroPath(event) {
+  if (typeof event.path === "string" && event.path.length > 0) {
+    return event.path;
+  }
+  if (event.request?.url) {
+    return new URL(event.request.url).pathname;
+  }
+  const requestUrl = event.url ?? event.node?.req?.url ?? "/";
+  if (requestUrl.startsWith("http://") || requestUrl.startsWith("https://")) {
+    return new URL(requestUrl).pathname;
+  }
+  const queryIndex = requestUrl.indexOf("?");
+  return queryIndex >= 0 ? requestUrl.slice(0, queryIndex) : requestUrl;
+}
+function createNitroRequestLike(event) {
+  return createRequestLike(getNitroMethod(event), getNitroUrl(event), getNitroHeaders(event));
+}
+function getNitroStatus(event, response, fallbackStatus = 200) {
+  if (response instanceof Response) {
+    return response.status;
+  }
+  if (typeof response?.status === "number") {
+    return response.status;
+  }
+  if (typeof response?.statusCode === "number") {
+    return response.statusCode;
+  }
+  if (typeof event.node?.res?.statusCode === "number" && event.node.res.statusCode > 0) {
+    return event.node.res.statusCode;
+  }
+  return fallbackStatus;
+}
+async function readNitroBody(event) {
+  if (event.body !== void 0) {
+    return event.body;
+  }
+  if (event.request) {
+    const contentType = event.request.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const fallbackRequest = event.request.clone();
+      try {
+        return await event.request.json();
+      } catch {
+        return await fallbackRequest.text();
+      }
+    }
+    return await event.request.text();
+  }
+  if (event.node?.req) {
+    return await readNodeRequestBody(event.node.req);
+  }
+  throw new Error("Unable to parse Nitro request body");
+}
+
+// src/frameworks/nitro/logger.ts
+function createContext6(event, response, error) {
+  return { event, response, error };
+}
+function buildFactory(shared) {
+  const getLogger = (event) => event.context.blypLog ?? shared.logger;
+  const logSuccess = async (event, response) => {
+    const state = getNitroState(event);
+    if (!state || state.structuredLogEmitted || state.errorLogged) {
+      return;
+    }
+    const requestLike = createNitroRequestLike(event);
+    const statusCode = getNitroStatus(event, response);
+    const responseTime = Math.round(performance.now() - state.startTime);
+    const loggerContext = createContext6(event, response);
+    if (isErrorStatus(statusCode)) {
+      if (!shouldSkipErrorLogging(shared, state.path)) {
+        emitHttpErrorLog(
+          shared.logger,
+          shared.level,
+          requestLike,
+          state.path,
+          statusCode,
+          responseTime,
+          toErrorLike(void 0, statusCode),
+          resolveAdditionalProps(shared, loggerContext)
+        );
+      }
+    } else if (!shouldSkipAutoLogging(shared, loggerContext, state.path)) {
+      emitHttpRequestLog(
+        shared.logger,
+        shared.level,
+        requestLike,
+        state.path,
+        statusCode,
+        responseTime,
+        resolveAdditionalProps(shared, loggerContext)
+      );
+    }
+  };
+  const logError = async (event, error, response) => {
+    const state = getNitroState(event);
+    if (!state || state.structuredLogEmitted || state.errorLogged || shouldSkipErrorLogging(shared, state.path)) {
+      return;
+    }
+    state.errorLogged = true;
+    emitHttpErrorLog(
+      shared.logger,
+      shared.level,
+      createNitroRequestLike(event),
+      state.path,
+      getNitroStatus(event, response, 500),
+      Math.round(performance.now() - state.startTime),
+      toErrorLike(error, 500),
+      resolveAdditionalProps(shared, createContext6(event, response, error)),
+      { error }
+    );
+  };
+  return {
+    logger: shared.logger,
+    getLogger,
+    plugin: async (nitroApp) => {
+      await nitroApp.hooks.hook("request", async (eventArg) => {
+        const event = eventArg;
+        enterRequestContext();
+        const path3 = getNitroPath(event);
+        let state = setNitroState(event, {
+          startTime: performance.now(),
+          path: path3,
+          structuredLogEmitted: false
+        });
+        const scopedLogger = createRequestScopedLogger(shared.logger, {
+          resolveStructuredFields: () => ({
+            method: getNitroMethod(event),
+            path: path3,
+            ...resolveAdditionalProps(shared, createContext6(event))
+          }),
+          onStructuredEmit: () => {
+            const currentState = getNitroState(event);
+            if (currentState) {
+              currentState.structuredLogEmitted = true;
+            }
+          }
+        });
+        event.context.blypLog = scopedLogger;
+        state.scopedLogger = scopedLogger;
+      });
+      await nitroApp.hooks.hook("beforeResponse", async (eventArg, payload) => {
+        await logSuccess(eventArg, payload);
+      });
+      await nitroApp.hooks.hook("afterResponse", async (eventArg) => {
+        await flushServerLoggerSafely(shared);
+        const state = getNitroState(eventArg);
+        if (state) {
+          state.errorLogged = true;
+        }
+      });
+      await nitroApp.hooks.hook("error", async (errorArg, eventArg) => {
+        if (eventArg && typeof eventArg === "object") {
+          await logError(eventArg, errorArg);
+          await flushServerLoggerSafely(shared);
+        }
+      });
+    },
+    clientLogHandler: async (event) => {
+      const path3 = getNitroPath(event);
+      if (path3 !== shared.ingestionPath) {
+        return new Response(
+          JSON.stringify({
+            error: `Mounted route path ${path3} does not match configured client logging path ${shared.ingestionPath}`
+          }),
+          {
+            status: 500,
+            headers: { "content-type": "application/json" }
+          }
+        );
+      }
+      const body = await readNitroBody(event);
+      const result = await handleClientLogIngestion({
+        config: shared,
+        ctx: createContext6(event),
+        request: {
+          ...createNitroRequestLike(event),
+          json: async () => body
+        },
+        body,
+        deliveryPath: path3
+      });
+      await flushServerLoggerSafely(shared);
+      return new Response(null, {
+        status: result.status,
+        headers: result.headers
+      });
+    }
+  };
+}
+function createNitroLogger(config = {}) {
+  const shared = resolveServerLogger(config);
+  return buildFactory(shared);
+}
+
+// src/frameworks/nuxt/logger.ts
+function createNuxtLogger(config = {}) {
+  const nitro = buildFactory(resolveServerLogger(config));
+  return {
+    logger: nitro.logger,
+    serverPlugin: nitro.plugin,
+    clientLogHandler: nitro.clientLogHandler,
+    getLogger: (event) => nitro.getLogger(event)
+  };
+}
+
 // src/frameworks/nestjs/constants.ts
 var BLYP_NEST_LOGGER = /* @__PURE__ */ Symbol("BLYP_NEST_LOGGER");
 var BLYP_NEST_LOGGER_INIT_ERROR = "BlypModule.forRoot() requires createLogger(...) to run before NestFactory.create(AppModule).";
@@ -6389,7 +7445,7 @@ BlypModule = __decorateClass([
 ], BlypModule);
 
 // src/connectors/otlp/index.ts
-function resolveSender4(config = { name: "" }) {
+function resolveSender5(config = { name: "" }) {
   const registry = createOTLPRegistry(resolveConfig({
     ...config.connectors ? { connectors: config.connectors } : {}
   }));
@@ -6460,10 +7516,10 @@ function createOTLPLoggerInstance(sender, bindings = {}) {
   };
 }
 function createOtlpLogger(config = { name: "" }) {
-  return createOTLPLoggerInstance(resolveSender4(config));
+  return createOTLPLoggerInstance(resolveSender5(config));
 }
 function createStructuredOtlpLogger(groupId, initial, config) {
-  const sender = resolveSender4(config ?? { name: "" });
+  const sender = resolveSender5(config ?? { name: "" });
   return createStructuredLog(groupId, {
     initialFields: initial,
     write: (payload, message) => {
@@ -6489,6 +7545,6 @@ function createStructuredLog2(groupId, initial) {
   return activeLogger.createStructuredLog(groupId, initial);
 }
 
-export { BlypError, BlypModule, CUSTOM_LEVELS, DEFAULT_CLIENT_LOGGING_CONFIG, DEFAULT_CONFIG, DEFAULT_DATABASE_DELIVERY_CONFIG, DEFAULT_DATABASE_RETRY_CONFIG, DEFAULT_FILE_CONFIG, DEFAULT_ROTATION_CONFIG, HTTP_CODES2 as HTTP_CODES, captureBetterStackException, capturePosthogException, colors, createBaseLogger, createBetterStackErrorTracker, createBetterStackLogger, createDrizzleDatabaseAdapter, createElysiaLogger, createError, createExpressErrorLogger, createExpressLogger, createFastifyLogger, createHonoLogger, createLogDir, createElysiaLogger as createLogger, createNestLogger, createNextJsLogger, createOtlpLogger, createPosthogErrorTracker, createPosthogLogger, createPrismaDatabaseAdapter, createRuntimeAdapter, createSentryLogger, createStandaloneLogger, createStructuredBetterStackLogger, createStructuredLog2 as createStructuredLog, createStructuredOtlpLogger, createStructuredPosthogLogger, createStructuredSentryLogger, createSvelteKitLogger, createTanStackStartLogger, formatLogRecord, getArrowForMethod, getColoredLevel, getConfig, getHttpCode2 as getHttpCode, getMethodColor, getResponseTimeColor, getStatusColor, loadConfig, logger2 as logger, mergeBlypConfig, normalizeOTLPRecord, parseError, readLogFile, resetConfigCache, resolveConfig, resolveStatusCode, runtime, shouldIgnorePath, shouldLogTable };
+export { BlypError, BlypModule, CUSTOM_LEVELS, DEFAULT_CLIENT_LOGGING_CONFIG, DEFAULT_CONFIG, DEFAULT_DATABASE_DELIVERY_CONFIG, DEFAULT_DATABASE_RETRY_CONFIG, DEFAULT_FILE_CONFIG, DEFAULT_ROTATION_CONFIG, HTTP_CODES2 as HTTP_CODES, captureBetterStackException, captureDatabuddyException, capturePosthogException, colors, createAstroLogger, createBaseLogger, createBetterStackErrorTracker, createBetterStackLogger, createDatabuddyErrorTracker, createDatabuddyLogger, createDrizzleDatabaseAdapter, createElysiaLogger, createError, createExpressErrorLogger, createExpressLogger, createFastifyLogger, createHonoLogger, createLogDir, createElysiaLogger as createLogger, createNestLogger, createNextJsLogger, createNitroLogger, createNuxtLogger, createOtlpLogger, createPosthogErrorTracker, createPosthogLogger, createPrismaDatabaseAdapter, createReactRouterLogger, createRuntimeAdapter, createSentryLogger, createStandaloneLogger, createStructuredBetterStackLogger, createStructuredDatabuddyLogger, createStructuredLog2 as createStructuredLog, createStructuredOtlpLogger, createStructuredPosthogLogger, createStructuredSentryLogger, createSvelteKitLogger, createTanStackStartLogger, formatLogRecord, getArrowForMethod, getColoredLevel, getConfig, getHttpCode2 as getHttpCode, getMethodColor, getResponseTimeColor, getStatusColor, loadConfig, logger2 as logger, mergeBlypConfig, normalizeOTLPRecord, parseError, readLogFile, resetConfigCache, resolveConfig, resolveStatusCode, runtime, shouldIgnorePath, shouldLogTable };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map