@blyp/core 0.1.2 → 0.1.21

package/dist/index.js

@@ -10,6 +10,7 @@ var fflate = require('fflate');
 var crypto = require('crypto');
 var Sentry = require('@sentry/node');
 var node = require('@logtail/node');
+var node$1 = require('@databuddy/sdk/node');
 var apiLogs = require('@opentelemetry/api-logs');
 var exporterLogsOtlpHttp = require('@opentelemetry/exporter-logs-otlp-http');
 var resources = require('@opentelemetry/resources');
@@ -225,6 +226,7 @@ var CLIENT_LOG_LEVELS = [
 ];
 var clientConnectorRequestSchema = zod.z.union([
   zod.z.literal("betterstack"),
+  zod.z.literal("databuddy"),
   zod.z.literal("posthog"),
   zod.z.literal("sentry"),
   zod.z.undefined(),
@@ -265,16 +267,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;
@@ -282,11 +284,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
@@ -652,6 +654,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;
@@ -742,6 +766,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)
@@ -1858,10 +1883,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 node$1.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(/\/+$/, "");
@@ -1902,7 +2235,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 {};
   }
@@ -1934,18 +2267,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") {
@@ -2021,12 +2354,12 @@ function resolveSeverity(level) {
       return { text: "info", number: apiLogs.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
@@ -2080,7 +2413,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;
@@ -2103,11 +2436,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();
@@ -2119,16 +2452,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."
     );
@@ -2166,7 +2499,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
@@ -2174,7 +2507,7 @@ function createPostHogSender(config) {
           });
         }
       } catch (error) {
-        warnOnce4(
+        warnOnce5(
           `posthog-emit:${key}`,
           "[Blyp] Failed to deliver log to PostHog.",
           error
@@ -2191,7 +2524,7 @@ function createPostHogSender(config) {
       if (isPreviouslyCapturedPostHogError(error)) {
         return;
       }
-      const normalized = normalizeExceptionInput2(
+      const normalized = normalizeExceptionInput3(
         error,
         options.source === "client" ? "Client error" : "Server error"
       );
@@ -2210,7 +2543,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
@@ -2218,7 +2551,7 @@ function createPostHogSender(config) {
           });
         }
       } catch (captureError) {
-        warnOnce4(
+        warnOnce5(
           `posthog-capture:${key}`,
           "[Blyp] Failed to capture exception in PostHog.",
           captureError
@@ -2231,7 +2564,7 @@ function createPostHogSender(config) {
           await transport.flush();
         }
       } catch (error) {
-        warnOnce4(
+        warnOnce5(
           `posthog-flush:${key}`,
           "[Blyp] Failed to flush PostHog telemetry.",
           error
@@ -2246,13 +2579,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__namespace;
+  return testHooks4.module ?? Sentry__namespace;
 }
-function resolveConnectorConfig3(config) {
+function resolveConnectorConfig4(config) {
   const connector = isBlypConfig(config) ? config.connectors?.sentry : config;
   const enabled = connector?.enabled ?? false;
   const dsn = connector?.dsn;
@@ -2397,7 +2730,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;
@@ -2411,7 +2744,7 @@ function createSentrySender(config) {
       });
       client = module.getClient();
     } catch (error) {
-      warnOnce5(
+      warnOnce6(
         `sentry-init:${key}`,
         "[Blyp] Failed to initialize Sentry. Skipping Sentry delivery.",
         error
@@ -2419,14 +2752,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."
     );
@@ -2452,7 +2785,7 @@ function createSentrySender(config) {
       try {
         logMethod(record.message, attributes);
       } catch (error) {
-        warnOnce5(
+        warnOnce6(
           `sentry-log:${key}`,
           "[Blyp] Failed to deliver log to Sentry.",
           error
@@ -2470,7 +2803,7 @@ function createSentrySender(config) {
           module.captureException(exception);
         });
       } catch (error) {
-        warnOnce5(
+        warnOnce6(
           `sentry-exception:${key}`,
           "[Blyp] Failed to capture exception in Sentry.",
           error
@@ -2481,7 +2814,7 @@ function createSentrySender(config) {
       try {
         await module.flush(2e3);
       } catch (error) {
-        warnOnce5(
+        warnOnce6(
           `sentry-flush:${key}`,
           "[Blyp] Failed to flush Sentry logs.",
           error
@@ -2490,9 +2823,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);
@@ -2557,14 +2890,14 @@ function resolveSeverity2(level) {
       return { text: "info", number: apiLogs.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
@@ -2641,7 +2974,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.`
     );
@@ -2672,7 +3005,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,
@@ -2688,7 +3021,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
@@ -2696,7 +3029,7 @@ function createSender(connector) {
           });
         }
       } catch (error) {
-        warnOnce6(
+        warnOnce7(
           `otlp-emit:${key}`,
           `[Blyp] Failed to deliver log to OTLP target "${connector.name}".`,
           error
@@ -2709,7 +3042,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
@@ -2738,7 +3071,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 {
@@ -3136,6 +3469,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);
@@ -3150,6 +3486,13 @@ function tryGetBetterStackSender(logger3) {
     return null;
   }
 }
+function tryGetDatabuddySender(logger3) {
+  try {
+    return getDatabuddySender(logger3);
+  } catch {
+    return null;
+  }
+}
 function getSentrySender(logger3) {
   return getLoggerFactory(logger3).sentry;
 }
@@ -3209,6 +3552,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;
@@ -3229,7 +3584,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()) {
@@ -3255,6 +3610,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);
@@ -3278,6 +3634,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);
@@ -3311,8 +3668,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
@@ -3324,6 +3699,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
         rootRawLogger,
         sink,
         betterstack,
+        databuddy,
         posthog,
         sentry,
         otlp,
@@ -3334,6 +3710,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
     [LOGGER_FACTORY]: {
       bindings,
       betterstack,
+      databuddy,
       posthog,
       sentry,
       otlp,
@@ -3343,6 +3720,7 @@ function createLoggerInstance(rootRawLogger, sink, betterstack, posthog, sentry,
           rootRawLogger,
           sink,
           betterstack,
+          databuddy,
           posthog,
           sentry,
           otlp,
@@ -3366,6 +3744,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);
@@ -3373,6 +3752,7 @@ function createBaseLogger(config) {
     rawLogger,
     sink,
     betterstack,
+    databuddy,
     posthog,
     sentry,
     otlp
@@ -3988,11 +4368,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,
@@ -4372,8 +4769,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 } : {}
   }));
@@ -4466,10 +4987,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) => {
@@ -4489,14 +5010,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 } : {}
   }));
@@ -4566,10 +5087,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) => {
@@ -4864,6 +5385,7 @@ function resolveServerLogger(config = {}, loggerOverride) {
   return {
     logger: logger3,
     betterstack: getBetterStackSender(logger3),
+    databuddy: getDatabuddySender(logger3),
     posthog: getPostHogSender(logger3),
     sentry: getSentrySender(logger3),
     otlp: getOtlpRegistry(logger3),
@@ -4983,6 +5505,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) {
@@ -5074,6 +5612,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) {
@@ -5740,8 +6306,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 = {}) {
@@ -5760,7 +6478,7 @@ function createTanStackStartLogger(config = {}) {
           resolveStructuredFields: () => ({
             method: request.method,
             path: path3,
-            ...resolveAdditionalProps(shared, createContext2(request, nextContext))
+            ...resolveAdditionalProps(shared, createContext3(request, nextContext))
           }),
           onStructuredEmit: () => {
             structuredLogEmitted = true;
@@ -5774,7 +6492,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)) {
@@ -5812,7 +6530,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
               }
@@ -5841,7 +6559,7 @@ function createTanStackStartLogger(config = {}) {
         }
         const result = await handleClientLogIngestion({
           config: shared,
-          ctx: createContext2(request, {}),
+          ctx: createContext3(request, {}),
           request,
           deliveryPath: path3
         });
@@ -5856,7 +6574,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 = {}) {
@@ -5868,7 +6586,7 @@ function createSvelteKitLogger(config = {}) {
         resolveStructuredFields: () => ({
           method: event.request.method,
           path: event.url.pathname,
-          ...resolveAdditionalProps(shared, createContext3(event))
+          ...resolveAdditionalProps(shared, createContext4(event))
         }),
         onStructuredEmit: () => {
           structuredLogEmitted = true;
@@ -5888,7 +6606,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)) {
@@ -5926,7 +6644,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
             }
@@ -5957,7 +6675,7 @@ function createSvelteKitLogger(config = {}) {
       }
       const result = await handleClientLogIngestion({
         config: shared,
-        ctx: createContext3(event),
+        ctx: createContext4(event),
         request: event.request,
         deliveryPath: path3
       });
@@ -5970,6 +6688,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).";
@@ -6417,7 +7473,7 @@ exports.BlypModule = __decorateClass([
 ], exports.BlypModule);
 
 // src/connectors/otlp/index.ts
-function resolveSender4(config = { name: "" }) {
+function resolveSender5(config = { name: "" }) {
   const registry = createOTLPRegistry(resolveConfig({
     ...config.connectors ? { connectors: config.connectors } : {}
   }));
@@ -6488,10 +7544,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) => {
@@ -6527,11 +7583,15 @@ exports.DEFAULT_FILE_CONFIG = DEFAULT_FILE_CONFIG;
 exports.DEFAULT_ROTATION_CONFIG = DEFAULT_ROTATION_CONFIG;
 exports.HTTP_CODES = HTTP_CODES2;
 exports.captureBetterStackException = captureBetterStackException;
+exports.captureDatabuddyException = captureDatabuddyException;
 exports.capturePosthogException = capturePosthogException;
 exports.colors = colors;
+exports.createAstroLogger = createAstroLogger;
 exports.createBaseLogger = createBaseLogger;
 exports.createBetterStackErrorTracker = createBetterStackErrorTracker;
 exports.createBetterStackLogger = createBetterStackLogger;
+exports.createDatabuddyErrorTracker = createDatabuddyErrorTracker;
+exports.createDatabuddyLogger = createDatabuddyLogger;
 exports.createDrizzleDatabaseAdapter = createDrizzleDatabaseAdapter;
 exports.createElysiaLogger = createElysiaLogger;
 exports.createError = createError;
@@ -6543,14 +7603,18 @@ exports.createLogDir = createLogDir;
 exports.createLogger = createElysiaLogger;
 exports.createNestLogger = createNestLogger;
 exports.createNextJsLogger = createNextJsLogger;
+exports.createNitroLogger = createNitroLogger;
+exports.createNuxtLogger = createNuxtLogger;
 exports.createOtlpLogger = createOtlpLogger;
 exports.createPosthogErrorTracker = createPosthogErrorTracker;
 exports.createPosthogLogger = createPosthogLogger;
 exports.createPrismaDatabaseAdapter = createPrismaDatabaseAdapter;
+exports.createReactRouterLogger = createReactRouterLogger;
 exports.createRuntimeAdapter = createRuntimeAdapter;
 exports.createSentryLogger = createSentryLogger;
 exports.createStandaloneLogger = createStandaloneLogger;
 exports.createStructuredBetterStackLogger = createStructuredBetterStackLogger;
+exports.createStructuredDatabuddyLogger = createStructuredDatabuddyLogger;
 exports.createStructuredLog = createStructuredLog2;
 exports.createStructuredOtlpLogger = createStructuredOtlpLogger;
 exports.createStructuredPosthogLogger = createStructuredPosthogLogger;