@blyp/core 0.1.2 → 0.1.21

package/dist/connectors/databuddy.mjs

@@ -0,0 +1,1451 @@
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { createJiti } from 'jiti';
+import { resolve, dirname } from 'path';
+import { z } from 'zod';
+import { Databuddy } from '@databuddy/sdk/node';
+import 'fflate';
+
+// src/core/config.ts
+
+// src/shared/log-value.ts
+function normalizeError(error) {
+  const normalized = {
+    name: error.name,
+    message: error.message
+  };
+  if (error.stack) {
+    normalized.stack = error.stack;
+  }
+  const errorWithCause = error;
+  if (errorWithCause.cause !== void 0) {
+    normalized.cause = normalizeLogValue(errorWithCause.cause);
+  }
+  return normalized;
+}
+function normalizeLogValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value instanceof Error) {
+    return normalizeError(value);
+  }
+  if (typeof value === "function") {
+    return `[Function: ${value.name || "anonymous"}]`;
+  }
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (value === void 0 || value === null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeLogValue(entry, seen));
+  }
+  if (typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    const normalized = {};
+    for (const [key, entry] of Object.entries(value)) {
+      normalized[key] = normalizeLogValue(entry, seen);
+    }
+    seen.delete(value);
+    return normalized;
+  }
+  return value;
+}
+function serializeLogMessage(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message instanceof Error) {
+    return message.message || message.name;
+  }
+  const normalized = normalizeLogValue(message);
+  if (typeof normalized === "string") {
+    return normalized;
+  }
+  try {
+    const serialized = JSON.stringify(normalized, null, 2);
+    return serialized ?? String(normalized);
+  } catch {
+    return String(normalized);
+  }
+}
+var absoluteHttpUrlSchema = z.string().url().refine((value) => {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:";
+  } catch {
+    return false;
+  }
+}, {
+  message: "Expected an absolute http(s) URL"
+});
+var plainObjectSchema = z.custom(
+  (value) => {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+  },
+  {
+    message: "Expected a plain object"
+  }
+);
+var nonEmptyStringSchema = z.string().trim().min(1);
+function isAbsoluteHttpUrl(value) {
+  return absoluteHttpUrlSchema.safeParse(value).success;
+}
+function isPlainObject(value) {
+  return plainObjectSchema.safeParse(value).success;
+}
+function hasNonEmptyString(value) {
+  return nonEmptyStringSchema.safeParse(value).success;
+}
+
+// src/shared/client-log.ts
+var DEFAULT_CLIENT_LOG_ENDPOINT = "/inngest";
+z.union([
+  z.literal("betterstack"),
+  z.literal("databuddy"),
+  z.literal("posthog"),
+  z.literal("sentry"),
+  z.undefined(),
+  z.object({
+    type: z.literal("otlp"),
+    name: nonEmptyStringSchema
+  })
+]);
+
+// src/shared/once.ts
+function createConsoleOnceLogger(method, warnedKeys3 = /* @__PURE__ */ new Set()) {
+  return (key, message, error) => {
+    if (warnedKeys3.has(key) || typeof console === "undefined") {
+      return;
+    }
+    const writer = console[method];
+    if (typeof writer !== "function") {
+      return;
+    }
+    warnedKeys3.add(key);
+    if (error === void 0) {
+      writer.call(console, message);
+      return;
+    }
+    writer.call(console, message, error);
+  };
+}
+function createWarnOnceLogger(warnedKeys3) {
+  return createConsoleOnceLogger("warn", warnedKeys3);
+}
+function createErrorOnceLogger(warnedKeys3) {
+  return createConsoleOnceLogger("error", warnedKeys3);
+}
+
+// src/core/config.ts
+var PACKAGE_NAME = "@blyp/core";
+var GITIGNORE_FILE_NAME = ".gitignore";
+var CONFIG_FILE_NAMES = [
+  "blyp.config.ts",
+  "blyp.config.mts",
+  "blyp.config.cts",
+  "blyp.config.js",
+  "blyp.config.mjs",
+  "blyp.config.cjs",
+  "blyp.config.json"
+];
+var CONFIG_FILE_NAME = "blyp.config.json";
+var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
+var DEFAULT_CONNECTOR_SERVICE_NAME = "blyp-app";
+var DEFAULT_POSTHOG_SERVICE_NAME = DEFAULT_CONNECTOR_SERVICE_NAME;
+var warnedKeys = /* @__PURE__ */ new Set();
+var warnOnce = createWarnOnceLogger(warnedKeys);
+var DEFAULT_ROTATION_CONFIG = {
+  enabled: true,
+  maxSizeBytes: 10 * 1024 * 1024,
+  maxArchives: 5,
+  compress: true
+};
+var DEFAULT_FILE_CONFIG = {
+  enabled: true,
+  dir: "",
+  archiveDir: "",
+  format: "ndjson",
+  rotation: DEFAULT_ROTATION_CONFIG
+};
+var DEFAULT_CLIENT_LOGGING_CONFIG = {
+  enabled: true,
+  path: DEFAULT_CLIENT_LOG_ENDPOINT
+};
+var DEFAULT_DATABASE_RETRY_CONFIG = {
+  maxRetries: 1,
+  backoffMs: 100
+};
+var DEFAULT_DATABASE_DELIVERY_CONFIG = {
+  strategy: "immediate",
+  batchSize: 1,
+  flushIntervalMs: 250,
+  maxQueueSize: 1e3,
+  overflowStrategy: "drop-oldest",
+  flushTimeoutMs: 5e3,
+  retry: DEFAULT_DATABASE_RETRY_CONFIG
+};
+var DEFAULT_CONFIG = {
+  pretty: true,
+  level: "info",
+  destination: "file",
+  file: DEFAULT_FILE_CONFIG,
+  clientLogging: DEFAULT_CLIENT_LOGGING_CONFIG,
+  connectors: {}
+};
+var cachedConfig = null;
+function findNearestPackageName(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const packageJsonPath = resolve(currentDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (hasNonEmptyString(packageJson.name)) {
+          return packageJson.name;
+        }
+      } catch {
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return void 0;
+    }
+    currentDir = parentDir;
+  }
+}
+function resolveDefaultConnectorServiceName(cwd = process.cwd()) {
+  return findNearestPackageName(cwd) ?? DEFAULT_POSTHOG_SERVICE_NAME;
+}
+function getBootstrapConfig() {
+  return {
+    pretty: true,
+    level: "info",
+    destination: "file",
+    file: {
+      enabled: true,
+      format: "ndjson",
+      rotation: {
+        enabled: true,
+        maxSizeBytes: 10 * 1024 * 1024,
+        maxArchives: 5,
+        compress: true
+      }
+    },
+    clientLogging: {
+      enabled: true,
+      path: DEFAULT_CLIENT_LOG_ENDPOINT
+    },
+    connectors: {}
+  };
+}
+function shouldBootstrapProjectFiles(cwd) {
+  const packageJsonPath = resolve(cwd, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return true;
+  }
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.name !== PACKAGE_NAME;
+  } catch {
+    return true;
+  }
+}
+function ensureConfigFile(cwd) {
+  if (CONFIG_FILE_NAMES.some((fileName) => existsSync(resolve(cwd, fileName)))) {
+    return;
+  }
+  const configPath = resolve(cwd, CONFIG_FILE_NAME);
+  if (existsSync(configPath)) {
+    return;
+  }
+  try {
+    writeFileSync(configPath, `${JSON.stringify(getBootstrapConfig(), null, 2)}
+`);
+  } catch (error) {
+    console.error("[Blyp] Warning: Failed to create blyp.config.json:", error);
+  }
+}
+function ensureLogsIgnored(cwd) {
+  const gitignorePath = resolve(cwd, GITIGNORE_FILE_NAME);
+  if (!existsSync(gitignorePath)) {
+    try {
+      writeFileSync(gitignorePath, "logs\n");
+    } catch (error) {
+      console.error("[Blyp] Warning: Failed to create .gitignore:", error);
+    }
+    return;
+  }
+  try {
+    const currentContent = readFileSync(gitignorePath, "utf-8");
+    if (/^(?:\/?logs\/?)\s*$/m.test(currentContent)) {
+      return;
+    }
+    const separator = currentContent.endsWith("\n") ? "" : "\n";
+    appendFileSync(gitignorePath, `${separator}logs
+`);
+  } catch (error) {
+    console.error("[Blyp] Warning: Failed to update .gitignore:", error);
+  }
+}
+function bootstrapProjectFiles() {
+  const cwd = process.cwd();
+  if (!shouldBootstrapProjectFiles(cwd)) {
+    return;
+  }
+  ensureConfigFile(cwd);
+  ensureLogsIgnored(cwd);
+}
+function findConfigFile() {
+  const cwd = process.cwd();
+  const matches = CONFIG_FILE_NAMES.map((fileName) => resolve(cwd, fileName)).filter((filePath) => existsSync(filePath));
+  if (matches.length === 0) {
+    return null;
+  }
+  if (matches.length > 1) {
+    const preferred = matches[0];
+    warnOnce(
+      `config-multiple:${preferred}`,
+      `[Blyp] Warning: Multiple config files found. Using ${preferred} and ignoring ${matches.slice(1).join(", ")}.`
+    );
+  }
+  const selectedPath = matches[0];
+  return {
+    path: selectedPath,
+    type: selectedPath.endsWith(".json") ? "json" : "jiti"
+  };
+}
+function normalizeLoadedConfig(value, configPath) {
+  const normalized = value && typeof value === "object" && "default" in value && value.default !== void 0 ? value.default : value;
+  if (!normalized || typeof normalized !== "object" || Array.isArray(normalized)) {
+    warnOnce(
+      `config-invalid:${configPath}`,
+      `[Blyp] Warning: Config file ${configPath} did not export an object. Falling back to defaults.`
+    );
+    return {};
+  }
+  return normalized;
+}
+function parseJsonConfigFile(configPath) {
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    return normalizeLoadedConfig(JSON.parse(content), configPath);
+  } catch (error) {
+    console.error("[Blyp] Warning: Failed to parse blyp.config.json:", error);
+    return {};
+  }
+}
+function parseExecutableConfigFile(configPath) {
+  try {
+    const jiti = createJiti(process.cwd(), {
+      interopDefault: true,
+      moduleCache: false,
+      fsCache: false
+    });
+    return normalizeLoadedConfig(jiti(configPath), configPath);
+  } catch (error) {
+    console.error(`[Blyp] Warning: Failed to load ${configPath}:`, error);
+    return {};
+  }
+}
+function parseConfigFile(config) {
+  return config.type === "json" ? parseJsonConfigFile(config.path) : parseExecutableConfigFile(config.path);
+}
+function isPrismaAdapter(value) {
+  return !!value && typeof value === "object" && value.type === "prisma";
+}
+function isDrizzleAdapter(value) {
+  return !!value && typeof value === "object" && value.type === "drizzle";
+}
+function mergeDatabaseRetryConfig(base, override) {
+  return {
+    ...DEFAULT_DATABASE_RETRY_CONFIG,
+    ...base,
+    ...override
+  };
+}
+function mergeDatabaseDeliveryConfig(base, override) {
+  return {
+    ...DEFAULT_DATABASE_DELIVERY_CONFIG,
+    ...base,
+    ...override,
+    retry: mergeDatabaseRetryConfig(base?.retry, override?.retry)
+  };
+}
+function hasPrismaDelegate(adapter) {
+  const model = adapter.model ?? "blypLog";
+  const client = adapter.client;
+  const delegate = client?.[model];
+  return !!delegate && typeof delegate.create === "function";
+}
+function hasDrizzleAdapterShape(adapter) {
+  const db = adapter.db;
+  return !!db && typeof db.insert === "function" && adapter.table !== void 0;
+}
+function resolveDatabaseLoggerConfig(config, sourceType) {
+  if (!config) {
+    return void 0;
+  }
+  const adapter = config.adapter;
+  let ready = false;
+  if (sourceType === "json") {
+    warnOnce(
+      "database-json-config",
+      "[Blyp] Warning: Database logging requires an executable blyp config file. Database destination remains disabled until you move this config to blyp.config.ts/js."
+    );
+  } else if (config.dialect !== "postgres" && config.dialect !== "mysql") {
+    warnOnce(
+      `database-dialect:${String(config.dialect)}`,
+      `[Blyp] Warning: Unsupported database dialect "${String(config.dialect)}". Database logging is disabled.`
+    );
+  } else if (!adapter) {
+    warnOnce(
+      "database-adapter-missing",
+      "[Blyp] Warning: Database logging is enabled without an adapter. Database logging is disabled."
+    );
+  } else if (isPrismaAdapter(adapter)) {
+    ready = hasPrismaDelegate({
+      ...adapter,
+      model: adapter.model ?? "blypLog"
+    });
+    if (!ready) {
+      warnOnce(
+        "database-prisma-missing",
+        `[Blyp] Warning: Prisma database adapter is missing the "${adapter.model ?? "blypLog"}" delegate or its create method. Database logging is disabled.`
+      );
+    }
+  } else if (isDrizzleAdapter(adapter)) {
+    ready = hasDrizzleAdapterShape(adapter);
+    if (!ready) {
+      warnOnce(
+        "database-drizzle-missing",
+        "[Blyp] Warning: Drizzle database adapter is missing a db.insert function or table reference. Database logging is disabled."
+      );
+    }
+  }
+  const normalizedAdapter = isPrismaAdapter(adapter) ? {
+    ...adapter,
+    model: adapter.model ?? "blypLog"
+  } : adapter;
+  return {
+    dialect: config.dialect,
+    adapter: normalizedAdapter,
+    delivery: mergeDatabaseDeliveryConfig(void 0, config.delivery),
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeRotationConfig(base, override) {
+  return {
+    ...DEFAULT_ROTATION_CONFIG,
+    ...base,
+    ...override
+  };
+}
+function mergeFileConfig(base, override) {
+  return {
+    ...DEFAULT_FILE_CONFIG,
+    ...base,
+    ...override,
+    rotation: mergeRotationConfig(base?.rotation, override?.rotation)
+  };
+}
+function mergeClientLoggingConfig(base, override) {
+  return {
+    ...DEFAULT_CLIENT_LOGGING_CONFIG,
+    ...base,
+    ...override,
+    path: override?.path ?? base?.path ?? DEFAULT_CLIENT_LOGGING_CONFIG.path
+  };
+}
+function mergeDatabaseLoggerConfig(base, override, sourceType) {
+  if (!base && !override) {
+    return void 0;
+  }
+  return resolveDatabaseLoggerConfig(
+    {
+      dialect: override?.dialect ?? base?.dialect,
+      adapter: override?.adapter ?? base?.adapter,
+      delivery: {
+        ...base?.delivery ?? {},
+        ...override?.delivery ?? {},
+        retry: {
+          ...base?.delivery?.retry ?? {},
+          ...override?.delivery?.retry ?? {}
+        }
+      }
+    },
+    sourceType
+  );
+}
+function mergePostHogConnectorConfig(base, override) {
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const projectKey = override?.projectKey ?? base?.projectKey;
+  const baseErrorTracking = base?.enabled === true ? base?.errorTracking : void 0;
+  const errorTrackingMode = override?.errorTracking?.mode ?? baseErrorTracking?.mode ?? "auto";
+  const errorTrackingEnabled = override?.errorTracking?.enabled ?? baseErrorTracking?.enabled ?? enabled;
+  const errorTrackingReady = enabled && errorTrackingEnabled && typeof projectKey === "string" && projectKey.trim().length > 0;
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    projectKey,
+    host: override?.host ?? base?.host ?? DEFAULT_POSTHOG_HOST,
+    serviceName: override?.serviceName ?? base?.serviceName ?? resolveDefaultConnectorServiceName(),
+    errorTracking: {
+      enabled: errorTrackingEnabled,
+      mode: errorTrackingMode,
+      enableExceptionAutocapture: override?.errorTracking?.enableExceptionAutocapture ?? baseErrorTracking?.enableExceptionAutocapture ?? errorTrackingMode === "auto",
+      ready: errorTrackingReady,
+      status: errorTrackingReady ? "enabled" : "missing"
+    }
+  };
+}
+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;
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const baseErrorTracking = base?.enabled === true ? base?.errorTracking : void 0;
+  const errorTracking = mergeBetterStackErrorTrackingConfig(
+    enabled,
+    baseErrorTracking,
+    override?.errorTracking
+  );
+  const ready = enabled && hasNonEmptyString(sourceToken) && isAbsoluteHttpUrl(ingestingHost);
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    sourceToken,
+    ingestingHost,
+    serviceName: override?.serviceName ?? base?.serviceName ?? resolveDefaultConnectorServiceName(),
+    errorTracking,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeBetterStackErrorTrackingConfig(connectorEnabled, base, override) {
+  const dsn = override?.dsn ?? base?.dsn;
+  const enabled = override?.enabled ?? base?.enabled ?? connectorEnabled;
+  const ready = enabled && hasNonEmptyString(dsn);
+  return {
+    enabled,
+    dsn,
+    tracesSampleRate: override?.tracesSampleRate ?? base?.tracesSampleRate ?? 1,
+    environment: override?.environment ?? base?.environment,
+    release: override?.release ?? base?.release,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeSentryConnectorConfig(base, override) {
+  const dsn = override?.dsn ?? base?.dsn;
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const ready = enabled && typeof dsn === "string" && dsn.trim().length > 0;
+  return {
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    dsn,
+    environment: override?.environment ?? base?.environment,
+    release: override?.release ?? base?.release,
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeOTLPConnectorConfig(base, override) {
+  const endpoint = override?.endpoint ?? base?.endpoint;
+  const enabled = override?.enabled ?? base?.enabled ?? false;
+  const resolvedHeaders = {
+    ...{},
+    ...override?.headers ?? {}
+  };
+  const ready = enabled && isAbsoluteHttpUrl(endpoint);
+  return {
+    name: override?.name ?? base?.name ?? "",
+    enabled,
+    mode: override?.mode ?? base?.mode ?? "auto",
+    endpoint,
+    headers: resolvedHeaders,
+    auth: override?.auth ?? base?.auth,
+    serviceName: override?.serviceName ?? base?.serviceName ?? resolveDefaultConnectorServiceName(),
+    ready,
+    status: ready ? "enabled" : "missing"
+  };
+}
+function mergeOTLPConnectorsConfig(base, override) {
+  const source = override ?? base ?? [];
+  const deduped = /* @__PURE__ */ new Map();
+  for (const connector of source) {
+    if (!connector || typeof connector.name !== "string" || connector.name.length === 0) {
+      continue;
+    }
+    if (deduped.has(connector.name)) {
+      warnOnce(
+        `otlp-duplicate:${connector.name}`,
+        `[Blyp] Warning: Duplicate OTLP connector name "${connector.name}" found. Using the last definition.`
+      );
+    }
+    deduped.set(connector.name, mergeOTLPConnectorConfig(void 0, connector));
+  }
+  return Array.from(deduped.values());
+}
+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)
+  };
+}
+function mergeBlypConfig(base, override = {}, options = {}) {
+  return {
+    ...base,
+    ...override,
+    destination: override.destination ?? base.destination ?? "file",
+    file: mergeFileConfig(base.file, override.file),
+    database: mergeDatabaseLoggerConfig(base.database, override.database, options.configFileType),
+    clientLogging: mergeClientLoggingConfig(base.clientLogging, override.clientLogging),
+    connectors: mergeConnectorsConfig(base.connectors, override.connectors)
+  };
+}
+function loadConfig() {
+  if (cachedConfig !== null) {
+    return cachedConfig;
+  }
+  bootstrapProjectFiles();
+  const configFile = findConfigFile();
+  if (configFile) {
+    const userConfig = parseConfigFile(configFile);
+    cachedConfig = mergeBlypConfig(DEFAULT_CONFIG, userConfig, {
+      configFileType: configFile.type
+    });
+  } else {
+    cachedConfig = mergeBlypConfig(DEFAULT_CONFIG);
+  }
+  return cachedConfig;
+}
+function resolveConfig(overrides = {}) {
+  return mergeBlypConfig(loadConfig(), overrides);
+}
+
+// src/core/log-record.ts
+var RECORD_LEVELS = {
+  success: "success",
+  critical: "critical",
+  warning: "warning",
+  info: "info",
+  debug: "debug",
+  error: "error",
+  warn: "warning",
+  table: "table"
+};
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function isInternalLoggerFrame(filePath) {
+  const normalizedPath = normalizePath(filePath);
+  return normalizedPath.startsWith("node:") || normalizedPath.includes("/node_modules/pino") || normalizedPath.includes("/node_modules/pino-pretty") || normalizedPath.includes("/node_modules/@blyp/core/") || normalizedPath.includes("/blyp/src/core/") || normalizedPath.includes("/blyp/src/frameworks/") || normalizedPath.includes("/blyp/src/posthog/") || normalizedPath.includes("/blyp/dist/");
+}
+function formatCallerPath(filePath) {
+  const normalizedPath = normalizePath(filePath);
+  const normalizedCwd = normalizePath(process.cwd());
+  return normalizedPath.startsWith(`${normalizedCwd}/`) ? normalizedPath.slice(normalizedCwd.length + 1) : normalizedPath;
+}
+function getCallerLocation() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) {
+      return { file: null, line: null };
+    }
+    const lines = stack.split("\n");
+    let fallback = null;
+    for (let index = 2; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (!line) {
+        continue;
+      }
+      const match = line.match(/\((.*):(\d+):\d+\)/) || line.match(/at\s+(.*):(\d+):(\d+)/);
+      if (!match) {
+        continue;
+      }
+      const fileName = match[1] || "";
+      const lineNumber = parseInt(match[2] || "0", 10) || null;
+      if (fileName && !fileName.includes("node_modules") && !isInternalLoggerFrame(fileName)) {
+        const formattedPath = formatCallerPath(fileName);
+        const normalizedFormattedPath = normalizePath(formattedPath);
+        if (!normalizedFormattedPath.startsWith("dist/")) {
+          return { file: formattedPath, line: lineNumber };
+        }
+        fallback ?? (fallback = { file: formattedPath, line: lineNumber });
+      }
+    }
+    if (fallback) {
+      return fallback;
+    }
+  } catch {
+    return { file: null, line: null };
+  }
+  return { file: null, line: null };
+}
+var serializeMessage = serializeLogMessage;
+function stripAnsi(value) {
+  return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function buildRecord(level, message, args, bindings) {
+  const { file, line } = getCallerLocation();
+  const serializedMessage = serializeMessage(message);
+  const record = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level: RECORD_LEVELS[level],
+    message: stripAnsi(serializedMessage)
+  };
+  if (message instanceof Error) {
+    record.error = normalizeError(message);
+  }
+  if (file) {
+    record.caller = line !== null ? `${file}:${line}` : file;
+  }
+  if (args.length === 1) {
+    record.data = normalizeLogValue(args[0]);
+  } else if (args.length > 1) {
+    record.data = normalizeLogValue(args);
+  }
+  if (Object.keys(bindings).length > 0) {
+    record.bindings = normalizeLogValue(bindings);
+  }
+  return record;
+}
+function buildStructuredRecord(level, message, payload, bindings) {
+  const { file, line } = getCallerLocation();
+  const normalizedPayload = normalizeLogValue(payload);
+  const record = {
+    message: stripAnsi(message),
+    ...normalizedPayload
+  };
+  if (file) {
+    record.caller = line !== null ? `${file}:${line}` : file;
+  }
+  if (Object.keys(bindings).length > 0) {
+    record.bindings = normalizeLogValue(bindings);
+  }
+  record.level = typeof normalizedPayload.level === "string" && normalizedPayload.level.length > 0 ? normalizedPayload.level : RECORD_LEVELS[level];
+  record.timestamp = typeof normalizedPayload.timestamp === "string" && normalizedPayload.timestamp.length > 0 ? normalizedPayload.timestamp : (/* @__PURE__ */ new Date()).toISOString();
+  return record;
+}
+function resolveStructuredWriteLevel(level) {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "warning":
+      return "warning";
+    case "warn":
+      return "warn";
+    case "error":
+      return "error";
+    case "success":
+      return "success";
+    case "critical":
+      return "critical";
+    case "table":
+      return "table";
+    case "info":
+    default:
+      return "info";
+  }
+}
+
+// src/core/structured-log.ts
+function serializeMessage2(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message !== null && typeof message === "object") {
+    try {
+      return JSON.stringify(
+        message,
+        (_key, value) => {
+          if (typeof value === "function") {
+            return `[Function: ${value.name || "anonymous"}]`;
+          }
+          if (value === void 0) {
+            return "[undefined]";
+          }
+          if (typeof value === "symbol") {
+            return value.toString();
+          }
+          return value;
+        },
+        2
+      );
+    } catch {
+      return "[Object]";
+    }
+  }
+  return String(message);
+}
+function normalizeEventData(message, args) {
+  if (typeof message === "string") {
+    if (args.length === 0) {
+      return void 0;
+    }
+    return args.length === 1 ? args[0] : args;
+  }
+  const values = [message, ...args];
+  return values.length === 1 ? values[0] : values;
+}
+function normalizeDetails(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeError2(error, fallbackStatus) {
+  if (error === void 0 || error === null) {
+    return fallbackStatus === void 0 || fallbackStatus < 400 ? void 0 : {
+      message: `HTTP ${fallbackStatus}`,
+      code: fallbackStatus,
+      type: "HttpError"
+    };
+  }
+  if (error instanceof Error) {
+    const errorLike = error;
+    return {
+      message: error.message,
+      code: errorLike.code,
+      type: errorLike.type ?? error.name ?? error.constructor?.name,
+      stack: error.stack,
+      why: errorLike.why,
+      fix: errorLike.fix,
+      link: errorLike.link,
+      details: normalizeDetails(errorLike.details),
+      cause: errorLike.cause
+    };
+  }
+  if (typeof error === "object") {
+    const record = error;
+    const statusCode = typeof record.statusCode === "number" ? record.statusCode : typeof record.status === "number" ? record.status : fallbackStatus;
+    return {
+      message: typeof record.message === "string" ? record.message : `HTTP ${statusCode ?? 500}`,
+      code: typeof record.code === "string" || typeof record.code === "number" ? record.code : statusCode,
+      type: typeof record.type === "string" ? record.type : typeof record.name === "string" ? record.name : "Error",
+      stack: typeof record.stack === "string" ? record.stack : void 0,
+      why: typeof record.why === "string" ? record.why : void 0,
+      fix: typeof record.fix === "string" ? record.fix : void 0,
+      link: typeof record.link === "string" ? record.link : void 0,
+      details: normalizeDetails(record.details),
+      cause: record.cause
+    };
+  }
+  return {
+    message: String(error),
+    code: fallbackStatus,
+    type: typeof error
+  };
+}
+function resolveEmitStatus(options) {
+  if (options.response && typeof options.response.status === "number") {
+    return options.response.status;
+  }
+  if (typeof options.status === "number") {
+    return options.status;
+  }
+  if (options.error && typeof options.error === "object" && options.error !== null && typeof options.error.statusCode === "number") {
+    return options.error.statusCode;
+  }
+  if (options.error && typeof options.error === "object" && options.error !== null && typeof options.error.status === "number") {
+    return options.error.status;
+  }
+  return options.error ? 500 : void 0;
+}
+function createStructuredLog(groupId, options) {
+  const startedAt = performance.now();
+  const fields = { ...options.initialFields ?? {} };
+  const events = [];
+  let emittedPayload;
+  options.onCreate?.();
+  const appendEvent = (level, message, args) => {
+    events.push({
+      level,
+      message: serializeMessage2(message),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...normalizeEventData(message, args) === void 0 ? {} : { data: normalizeEventData(message, args) }
+    });
+    return structuredLog;
+  };
+  const structuredLog = {
+    set(extraFields) {
+      Object.assign(fields, extraFields);
+      return structuredLog;
+    },
+    debug(message, ...args) {
+      return appendEvent("debug", message, args);
+    },
+    info(message, ...args) {
+      return appendEvent("info", message, args);
+    },
+    warn(message, ...args) {
+      return appendEvent("warn", message, args);
+    },
+    warning(message, ...args) {
+      return appendEvent("warning", message, args);
+    },
+    error(message, ...args) {
+      return appendEvent("error", message, args);
+    },
+    success(message, ...args) {
+      return appendEvent("success", message, args);
+    },
+    critical(message, ...args) {
+      return appendEvent("critical", message, args);
+    },
+    table(message, data) {
+      return appendEvent("table", message, data === void 0 ? [] : [data]);
+    },
+    emit(emitOptions = {}) {
+      if (emittedPayload) {
+        return emittedPayload;
+      }
+      const defaultFields = options.resolveDefaultFields?.() ?? {};
+      const status = resolveEmitStatus(emitOptions);
+      const error = normalizeError2(emitOptions.error, status);
+      const level = emitOptions.level ?? (error ? "error" : "info");
+      const payload = {
+        ...defaultFields,
+        ...fields,
+        groupId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        duration: Math.round(performance.now() - startedAt),
+        ...typeof status === "number" ? { status } : {},
+        ...events.length > 0 ? { events: [...events] } : {},
+        ...error ? { error } : {}
+      };
+      options.write(payload, emitOptions.message ?? "structured_log");
+      emittedPayload = payload;
+      options.onEmit?.(payload);
+      return payload;
+    }
+  };
+  return structuredLog;
+}
+function createSafeReplacer() {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return (_key, value) => {
+    if (typeof value === "function") {
+      return `[Function: ${value.name || "anonymous"}]`;
+    }
+    if (value === void 0) {
+      return "[undefined]";
+    }
+    if (typeof value === "symbol") {
+      return value.toString();
+    }
+    if (value !== null && typeof value === "object") {
+      if (seen.has(value)) {
+        return "[Circular]";
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+}
+function serializeLogRecord(record) {
+  return JSON.stringify(record, createSafeReplacer());
+}
+
+// src/connectors/shared.ts
+function isBlypConfig(config) {
+  return isPlainObject(config) && ("connectors" in config || "pretty" in config || "level" in config);
+}
+function getPrimaryPayload(record) {
+  return isPlainObject(record.data) ? record.data : record;
+}
+function getField(record, key) {
+  if (key in record) {
+    const direct = record[key];
+    if (typeof direct === "string" || typeof direct === "number") {
+      return direct;
+    }
+  }
+  const payload = getPrimaryPayload(record);
+  const nested = payload[key];
+  if (typeof nested === "string" || typeof nested === "number") {
+    return nested;
+  }
+  return void 0;
+}
+function getClientPageField(record, key) {
+  const payload = getPrimaryPayload(record);
+  const page = isPlainObject(payload.page) ? payload.page : void 0;
+  const value = page?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getClientSessionField(record, key) {
+  const payload = getPrimaryPayload(record);
+  const session = isPlainObject(payload.session) ? payload.session : void 0;
+  const value = session?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+function getRecordType(record) {
+  return getField(record, "type");
+}
+
+// src/connectors/databuddy/sender.ts
+var warnedKeys2 = /* @__PURE__ */ new Set();
+var senderCache = /* @__PURE__ */ new Map();
+var testHooks = {};
+var warnOnce2 = createErrorOnceLogger(warnedKeys2);
+function registerShutdownHooks(key, shutdown) {
+  const handlers = ["beforeExit", "SIGINT", "SIGTERM"];
+  for (const event of handlers) {
+    process.once(event, () => {
+      void shutdown().catch((error) => {
+        warnOnce2(
+          `${key}:shutdown`,
+          "[Blyp] Failed to flush Databuddy telemetry during shutdown.",
+          error
+        );
+      });
+    });
+  }
+}
+function resolveConnectorConfig(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 createDefaultClient(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 path = 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", path],
+    ["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 normalizeExceptionInput(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 = resolveConnectorConfig(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 ? testHooks.createClient?.(connector) ?? createDefaultClient(connector) : void 0;
+  if (client) {
+    registerShutdownHooks(key, async () => {
+      await client.flush();
+    });
+  }
+  const emitUnavailableWarning = () => {
+    warnOnce2(
+      `databuddy-unavailable:${key}`,
+      "[Blyp] Databuddy connector is not configured. Databuddy requires both apiKey and websiteId. Skipping Databuddy delivery."
+    );
+  };
+  const emitExceptionUnavailableWarning = () => {
+    warnOnce2(
+      `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) => {
+            warnOnce2(
+              `databuddy-send:${key}`,
+              "[Blyp] Failed to deliver log to Databuddy.",
+              error
+            );
+          });
+        }
+      } catch (error) {
+        warnOnce2(
+          `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 = normalizeExceptionInput(
+        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) => {
+            warnOnce2(
+              `databuddy-capture:${key}`,
+              "[Blyp] Failed to capture exception in Databuddy.",
+              captureError
+            );
+          });
+        }
+      } catch (captureError) {
+        warnOnce2(
+          `databuddy-capture:${key}`,
+          "[Blyp] Failed to capture exception in Databuddy.",
+          captureError
+        );
+      }
+    },
+    async flush() {
+      try {
+        if (client) {
+          await client.flush();
+        }
+      } catch (error) {
+        warnOnce2(
+          `databuddy-flush:${key}`,
+          "[Blyp] Failed to flush Databuddy telemetry.",
+          error
+        );
+      }
+    }
+  };
+  senderCache.set(senderKey, sender);
+  return sender;
+}
+
+// src/connectors/databuddy/index.ts
+function resolveSender(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(resolveSender(config));
+}
+function createStructuredDatabuddyLogger(groupId, initial, config = {}) {
+  const sender = resolveSender(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(resolveSender(config));
+}
+function captureDatabuddyException(error, options = {}, config = {}) {
+  createDatabuddyErrorTracker(config).capture(error, options);
+}
+
+export { captureDatabuddyException, createDatabuddyErrorTracker, createDatabuddyLogger, createStructuredDatabuddyLogger };
+//# sourceMappingURL=databuddy.mjs.map
+//# sourceMappingURL=databuddy.mjs.map