@virtu3d/event-manager 0.2.7

package/dist/index.mjs

@@ -0,0 +1,999 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/connectors/base.connector.ts
+var BaseConnector = class {
+  constructor(config = {}) {
+    this.ready = false;
+    this.config = {
+      enabled: true,
+      debug: false,
+      ...config
+    };
+  }
+  async init() {
+    if (!this.config.enabled) {
+      this.log("Connector disabled, skipping init");
+      return;
+    }
+    await this.setup();
+    this.ready = true;
+  }
+  async shutdown() {
+    this.ready = false;
+  }
+  isReady() {
+    return this.ready && (this.config.enabled ?? true);
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[${this.name}] ${message}`, data || "");
+    }
+  }
+};
+
+// src/connectors/console.connector.ts
+var ConsoleConnector = class extends BaseConnector {
+  constructor(config = {}) {
+    super(config);
+    this.name = "console";
+    this.type = "custom";
+    this.prefix = config.prefix || "[Telemetry]";
+  }
+  setup() {
+  }
+  track(event) {
+    console.log(`${this.prefix} TRACK:`, event.name, event.payload);
+  }
+  identify(event) {
+    console.log(`${this.prefix} IDENTIFY:`, event.userId, event.traits);
+  }
+  page(event) {
+    console.log(`${this.prefix} PAGE:`, event.name, event.properties);
+  }
+};
+function createConsoleConnector(config) {
+  return new ConsoleConnector(config);
+}
+
+// src/connectors/otel.connector.ts
+var OtelConnector = class extends BaseConnector {
+  constructor(config) {
+    super(config);
+    this.name = "otel";
+    this.type = "observability";
+    this.serviceName = config.serviceName;
+    this.attributesExtractor = config.attributesExtractor;
+  }
+  async setup() {
+    const api = await import('@opentelemetry/api');
+    this.tracer = api.trace.getTracer(this.serviceName);
+    this.context = api.context;
+    this.log("OTEL tracer initialized");
+  }
+  track(event) {
+    if (!this.tracer) {
+      this.log("Tracer not initialized");
+      return;
+    }
+    const span = this.tracer.startSpan(event.name, {}, this.context.active());
+    span.setAttribute("event.name", event.name);
+    span.setAttribute("event.timestamp", event.timestamp || (/* @__PURE__ */ new Date()).toISOString());
+    if (this.attributesExtractor) {
+      const customAttrs = this.attributesExtractor(event);
+      Object.entries(customAttrs).forEach(([key, value]) => {
+        span.setAttribute(key, value);
+      });
+    }
+    Object.entries(event.payload).forEach(([key, value]) => {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        span.setAttribute(`payload.${key}`, value);
+      }
+    });
+    if (event.meta) {
+      Object.entries(event.meta).forEach(([key, value]) => {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          span.setAttribute(`meta.${key}`, value);
+        }
+      });
+    }
+    span.end();
+    this.log("Span created", { name: event.name });
+  }
+  identify(event) {
+    this.log("Identify received", { userId: event.userId });
+  }
+  page(event) {
+    this.track({
+      name: "page_view",
+      payload: { pageName: event.name, ...event.properties },
+      timestamp: event.timestamp
+    });
+  }
+};
+function createOtelConnector(config) {
+  return new OtelConnector(config);
+}
+
+// src/connectors/cloudwatch-emf.connector.ts
+var CloudWatchEmfConnector = class extends BaseConnector {
+  constructor(config) {
+    super(config);
+    this.name = "cloudwatch-emf";
+    this.type = "metrics";
+    this.namespace = config.namespace;
+    this.serviceName = config.serviceName;
+    this.region = config.region || process.env.AWS_REGION || "us-east-1";
+    this.metricMappings = config.metricMappings || {};
+  }
+  setup() {
+    this.log("CloudWatch EMF connector initialized", {
+      namespace: this.namespace,
+      serviceName: this.serviceName,
+      mappedEvents: Object.keys(this.metricMappings)
+    });
+  }
+  track(event) {
+    const mapping = this.metricMappings[event.name];
+    const metricConfig = mapping || {
+      metricName: this.toMetricName(event.name),
+      unit: "Count",
+      dimensions: ["service"]
+    };
+    const metricValue = metricConfig.valueField ? Number(event.payload[metricConfig.valueField]) || 1 : 1;
+    const dimensions = {
+      service: this.serviceName
+    };
+    if (metricConfig.dimensions) {
+      for (const dim of metricConfig.dimensions) {
+        if (dim !== "service" && event.payload[dim] !== void 0) {
+          dimensions[dim] = String(event.payload[dim]);
+        }
+      }
+    }
+    if (event.meta?.userId) dimensions["userId"] = String(event.meta.userId);
+    if (event.meta?.orgId) dimensions["orgId"] = String(event.meta.orgId);
+    const emfLog = {
+      _aws: {
+        Timestamp: Date.now(),
+        CloudWatchMetrics: [
+          {
+            Namespace: this.namespace,
+            Dimensions: [Object.keys(dimensions)],
+            Metrics: [
+              {
+                Name: metricConfig.metricName,
+                Unit: metricConfig.unit
+              }
+            ]
+          }
+        ]
+      },
+      // Dimensions as top-level fields
+      ...dimensions,
+      // Metric value
+      [metricConfig.metricName]: metricValue,
+      // Additional context (not dimensions, just for log inspection)
+      eventName: event.name,
+      timestamp: event.timestamp,
+      payload: event.payload
+    };
+    console.log(JSON.stringify(emfLog));
+    this.log("EMF metric emitted", {
+      metric: metricConfig.metricName,
+      value: metricValue,
+      dimensions
+    });
+  }
+  identify(event) {
+    const emfLog = {
+      _aws: {
+        Timestamp: Date.now(),
+        CloudWatchMetrics: [
+          {
+            Namespace: this.namespace,
+            Dimensions: [["service"]],
+            Metrics: [
+              {
+                Name: "UserIdentified",
+                Unit: "Count"
+              }
+            ]
+          }
+        ]
+      },
+      service: this.serviceName,
+      UserIdentified: 1,
+      userId: event.userId,
+      traits: event.traits
+    };
+    console.log(JSON.stringify(emfLog));
+  }
+  /**
+   * Convert event name to CloudWatch metric name
+   * e.g., 'ai_chat_completed' -> 'AiChatCompleted'
+   */
+  toMetricName(eventName) {
+    return eventName.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+};
+function createCloudWatchEmfConnector(config) {
+  return new CloudWatchEmfConnector(config);
+}
+
+// src/factories/index.ts
+var factoryRegistry = /* @__PURE__ */ new Map();
+function registerFactory(typeName, factory) {
+  factoryRegistry.set(typeName, factory);
+}
+function getFactory(typeName) {
+  return factoryRegistry.get(typeName);
+}
+function hasFactory(typeName) {
+  return factoryRegistry.has(typeName);
+}
+function getRegisteredFactories() {
+  return Array.from(factoryRegistry.keys());
+}
+function createConnector(typeName, config) {
+  const factory = factoryRegistry.get(typeName);
+  if (!factory) {
+    throw new Error(
+      `Unknown connector type: "${typeName}". Registered types: ${getRegisteredFactories().join(", ")}`
+    );
+  }
+  return factory(config);
+}
+function createConnectorsFromConfig(providers) {
+  return providers.filter((p) => p.enabled !== false).map((provider) => {
+    const connector = createConnector(provider.type, provider.config || {});
+    if (provider.name && provider.name !== connector.name) {
+      connector.name = provider.name;
+    }
+    return connector;
+  });
+}
+registerFactory("console", (config) => new ConsoleConnector(config));
+registerFactory("otel", (config) => new OtelConnector(config));
+registerFactory("cloudwatch-emf", (config) => new CloudWatchEmfConnector(config));
+registerFactory("mixpanel", (config) => {
+  try {
+    const dynamicRequire = new Function("modulePath", "return require(modulePath)");
+    const { MixpanelConnector: MixpanelConnector2 } = dynamicRequire("../connectors/mixpanel.connector");
+    return new MixpanelConnector2(config);
+  } catch (err) {
+    throw new Error(
+      'Mixpanel connector requires Node.js environment and the "mixpanel" package. Install with: npm install mixpanel'
+    );
+  }
+});
+registerFactory("posthog", (config) => {
+  try {
+    const dynamicRequire = new Function("modulePath", "return require(modulePath)");
+    const { PostHogConnector: PostHogConnector2 } = dynamicRequire("../connectors/posthog.connector");
+    return new PostHogConnector2(config);
+  } catch (err) {
+    throw new Error(
+      'PostHog connector requires Node.js environment and the "posthog-node" package. Install with: npm install posthog-node'
+    );
+  }
+});
+
+// src/core/router.ts
+var TelemetryRouter = class {
+  constructor(config = {}) {
+    this.connectors = /* @__PURE__ */ new Map();
+    this.plugins = [];
+    this.initialized = false;
+    this.config = {
+      debug: false,
+      globalMeta: {},
+      ...config
+    };
+    this.plugins = config.plugins || [];
+    if (config.providers && config.providers.length > 0) {
+      try {
+        const connectors = createConnectorsFromConfig(config.providers);
+        for (const connector of connectors) {
+          this.registerConnector(connector);
+        }
+      } catch (error) {
+        this.log("Failed to auto-register providers", error);
+      }
+    }
+  }
+  /**
+   * Initialize all registered connectors
+   */
+  async init() {
+    if (this.initialized) return;
+    const initPromises = Array.from(this.connectors.values()).map(
+      async (connector) => {
+        try {
+          await connector.init?.();
+          this.log(`Connector initialized: ${connector.name}`);
+        } catch (error) {
+          this.log(`Failed to initialize connector: ${connector.name}`, error);
+        }
+      }
+    );
+    await Promise.allSettled(initPromises);
+    this.initialized = true;
+  }
+  /**
+   * Register a connector instance directly
+   */
+  registerConnector(connector) {
+    if (this.connectors.has(connector.name)) {
+      this.log(`Connector "${connector.name}" already registered, replacing...`);
+    }
+    this.connectors.set(connector.name, connector);
+    this.log(`Connector registered: ${connector.name} (${connector.type})`);
+    return this;
+  }
+  /**
+   * Register connector using a factory
+   */
+  use(factory, config) {
+    const connector = factory.create(config);
+    return this.registerConnector(connector);
+  }
+  /**
+   * Unregister a connector by name
+   */
+  unregisterConnector(name) {
+    const connector = this.connectors.get(name);
+    if (connector) {
+      connector.shutdown?.();
+      this.connectors.delete(name);
+      this.log(`Connector unregistered: ${name}`);
+    }
+    return this;
+  }
+  /**
+   * Add a plugin
+   */
+  addPlugin(plugin) {
+    this.plugins.push(plugin);
+    this.log(`Plugin added: ${plugin.name}`);
+    return this;
+  }
+  /**
+   * Track a custom event
+   */
+  async track(eventName, payload = {}) {
+    const event = {
+      name: eventName,
+      payload,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      meta: { ...this.config.globalMeta }
+    };
+    return this.dispatch("track", event);
+  }
+  /**
+   * Identify a user
+   */
+  async identify(userId, traits = {}) {
+    const event = {
+      userId,
+      traits,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const telemetryEvent = {
+      name: "identify",
+      payload: { userId, traits },
+      timestamp: event.timestamp,
+      meta: { ...this.config.globalMeta, userId }
+    };
+    return this.dispatch("identify", telemetryEvent, event);
+  }
+  /**
+   * Track a page view
+   */
+  async page(name, properties = {}) {
+    const event = {
+      name,
+      properties,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const telemetryEvent = {
+      name: "page_view",
+      payload: { pageName: name, ...properties },
+      timestamp: event.timestamp,
+      meta: { ...this.config.globalMeta }
+    };
+    return this.dispatch("page", telemetryEvent, event);
+  }
+  /**
+   * Core dispatch method - sends to all connectors in parallel
+   */
+  async dispatch(method, event, originalEvent) {
+    let processedEvent = event;
+    for (const plugin of this.plugins) {
+      if (plugin.beforeDispatch) {
+        processedEvent = plugin.beforeDispatch(processedEvent);
+        if (!processedEvent) {
+          this.log(`Event blocked by plugin: ${plugin.name}`);
+          return {
+            event,
+            results: [],
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+    }
+    const connectors = Array.from(this.connectors.values());
+    const startTime = Date.now();
+    const settledResults = await Promise.allSettled(
+      connectors.map(async (connector) => {
+        const connectorStart = Date.now();
+        try {
+          switch (method) {
+            case "track":
+              await connector.track(processedEvent);
+              break;
+            case "identify":
+              await connector.identify?.(originalEvent);
+              break;
+            case "page":
+              await connector.page?.(originalEvent);
+              break;
+          }
+          return {
+            connector: connector.name,
+            success: true,
+            duration: Date.now() - connectorStart
+          };
+        } catch (error) {
+          return {
+            connector: connector.name,
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error)),
+            duration: Date.now() - connectorStart
+          };
+        }
+      })
+    );
+    const results = settledResults.map((result) => {
+      if (result.status === "fulfilled") {
+        return result.value;
+      }
+      return {
+        connector: "unknown",
+        success: false,
+        error: result.reason
+      };
+    });
+    this.log(`Event dispatched: ${event.name}`, {
+      duration: Date.now() - startTime,
+      results: results.map((r) => ({
+        connector: r.connector,
+        success: r.success
+      }))
+    });
+    for (const plugin of this.plugins) {
+      plugin.afterDispatch?.(processedEvent, results);
+    }
+    return {
+      event: processedEvent,
+      results,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Get all registered connector names
+   */
+  getConnectors() {
+    return Array.from(this.connectors.keys());
+  }
+  /**
+   * Get connectors by type
+   */
+  getConnectorsByType(type) {
+    return Array.from(this.connectors.values()).filter((c) => c.type === type).map((c) => c.name);
+  }
+  /**
+   * Shutdown all connectors
+   */
+  async shutdown() {
+    const shutdownPromises = Array.from(this.connectors.values()).map(
+      async (connector) => {
+        try {
+          await connector.shutdown?.();
+          this.log(`Connector shutdown: ${connector.name}`);
+        } catch (error) {
+          this.log(`Failed to shutdown connector: ${connector.name}`, error);
+        }
+      }
+    );
+    await Promise.allSettled(shutdownPromises);
+    this.connectors.clear();
+    this.initialized = false;
+  }
+  /**
+   * Internal logger
+   */
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[TelemetryRouter] ${message}`, data || "");
+    }
+  }
+};
+function createTelemetryRouter(config) {
+  return new TelemetryRouter(config);
+}
+
+// src/core/config.ts
+function validateConfig(config) {
+  if (!config.app) {
+    throw new Error('TelemetryConfig: "app" is required');
+  }
+  if (config.analytics.provider !== "none") {
+    const providerConfig = config.analytics[config.analytics.provider];
+    if (!providerConfig) {
+      throw new Error(
+        `TelemetryConfig: Missing config for analytics provider "${config.analytics.provider}"`
+      );
+    }
+  }
+  if (config.observability.provider !== "none") {
+    const providerConfig = config.observability[config.observability.provider];
+    if (!providerConfig) {
+      throw new Error(
+        `TelemetryConfig: Missing config for observability provider "${config.observability.provider}"`
+      );
+    }
+  }
+  if (config.metrics?.provider && config.metrics.provider !== "none") {
+    const key = config.metrics.provider === "cloudwatch-emf" ? "cloudwatchEmf" : config.metrics.provider;
+    const providerConfig = config.metrics[key];
+    if (!providerConfig) {
+      throw new Error(
+        `TelemetryConfig: Missing config for metrics provider "${config.metrics.provider}"`
+      );
+    }
+  }
+}
+
+// src/context/index.ts
+async function getTraceHeaders() {
+  try {
+    const { context, propagation, trace } = await import('@opentelemetry/api');
+    const headers = {};
+    propagation.inject(context.active(), headers);
+    if (!headers["traceparent"]) {
+      const traceId = generateTraceId();
+      const spanId = generateSpanId();
+      headers["traceparent"] = generateTraceparent(traceId, spanId, 1);
+    }
+    return headers;
+  } catch {
+    const traceId = generateTraceId();
+    const spanId = generateSpanId();
+    return {
+      traceparent: generateTraceparent(traceId, spanId, 1)
+    };
+  }
+}
+function getTraceHeadersSync() {
+  try {
+    const { context, propagation } = __require("@opentelemetry/api");
+    const headers = {};
+    propagation.inject(context.active(), headers);
+    if (!headers["traceparent"]) {
+      const traceId = generateTraceId();
+      const spanId = generateSpanId();
+      headers["traceparent"] = generateTraceparent(traceId, spanId, 1);
+    }
+    return headers;
+  } catch {
+    const traceId = generateTraceId();
+    const spanId = generateSpanId();
+    return {
+      traceparent: generateTraceparent(traceId, spanId, 1)
+    };
+  }
+}
+async function extractTraceContext(headers) {
+  try {
+    const { trace, context, propagation, isSpanContextValid } = await import('@opentelemetry/api');
+    const normalizedHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+      const lowerKey = key.toLowerCase();
+      if (typeof value === "string") {
+        normalizedHeaders[lowerKey] = value;
+      } else if (Array.isArray(value)) {
+        normalizedHeaders[lowerKey] = value[0] || "";
+      }
+    }
+    const extractedContext = propagation.extract(context.active(), normalizedHeaders);
+    const spanContext = trace.getSpanContext(extractedContext);
+    if (!spanContext || !isSpanContextValid(spanContext)) {
+      const traceparent = normalizedHeaders["traceparent"];
+      if (traceparent) {
+        const parsed = parseTraceparent(traceparent);
+        if (parsed) {
+          return {
+            traceId: parsed.traceId,
+            spanId: parsed.spanId,
+            traceFlags: parsed.traceFlags
+          };
+        }
+      }
+      return null;
+    }
+    return {
+      traceId: spanContext.traceId,
+      spanId: spanContext.spanId,
+      traceFlags: spanContext.traceFlags
+    };
+  } catch {
+    const traceparent = headers["traceparent"] || headers["Traceparent"];
+    if (traceparent) {
+      const value = typeof traceparent === "string" ? traceparent : traceparent[0];
+      const parsed = parseTraceparent(value || "");
+      if (parsed) {
+        return {
+          traceId: parsed.traceId,
+          spanId: parsed.spanId,
+          traceFlags: parsed.traceFlags
+        };
+      }
+    }
+    return null;
+  }
+}
+async function withTraceContext(headers, fn) {
+  try {
+    const { context, propagation } = await import('@opentelemetry/api');
+    const normalizedHeaders = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (typeof value === "string") {
+        normalizedHeaders[key] = value;
+      } else if (Array.isArray(value)) {
+        normalizedHeaders[key] = value[0] || "";
+      }
+    }
+    const extractedContext = propagation.extract(context.active(), normalizedHeaders);
+    return context.with(extractedContext, fn);
+  } catch {
+    return fn();
+  }
+}
+async function startSpan(name, serviceName = "telemetry") {
+  try {
+    const { trace } = await import('@opentelemetry/api');
+    const tracer = trace.getTracer(serviceName);
+    return tracer.startSpan(name);
+  } catch {
+    return {
+      setAttribute: () => {
+      },
+      setStatus: () => {
+      },
+      addEvent: () => {
+      },
+      end: () => {
+      },
+      spanContext: () => ({ traceId: "", spanId: "", traceFlags: 0 })
+    };
+  }
+}
+function parseTraceparent(traceparent) {
+  if (!traceparent) return null;
+  const parts = traceparent.split("-");
+  if (parts.length !== 4) return null;
+  const [version, traceId, spanId, flags] = parts;
+  if (version.length !== 2 || traceId.length !== 32 || spanId.length !== 16 || flags.length !== 2) {
+    return null;
+  }
+  return {
+    version,
+    traceId,
+    spanId,
+    traceFlags: parseInt(flags, 16)
+  };
+}
+function generateTraceparent(traceId, spanId, traceFlags = 1) {
+  const flagsHex = traceFlags.toString(16).padStart(2, "0");
+  return `00-${traceId}-${spanId}-${flagsHex}`;
+}
+function generateTraceId() {
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateSpanId() {
+  const bytes = new Uint8Array(8);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/utils/index.ts
+function detectEnvironment() {
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const randomPart = Math.random().toString(36).substring(2, 10);
+  return `${timestamp}-${randomPart}`;
+}
+function generateEventId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function safeStringify(obj, space) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  return JSON.stringify(
+    obj,
+    (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) {
+          return "[Circular]";
+        }
+        seen.add(value);
+      }
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      if (value instanceof Error) {
+        return {
+          name: value.name,
+          message: value.message,
+          stack: value.stack
+        };
+      }
+      return value;
+    },
+    space
+  );
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (isObject(sourceValue) && isObject(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sanitizePayload(payload, sensitiveFields = ["password", "token", "secret", "apiKey", "api_key", "authorization"]) {
+  const result = {};
+  for (const [key, value] of Object.entries(payload)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveFields.some((field) => lowerKey.includes(field.toLowerCase()))) {
+      result[key] = "[REDACTED]";
+    } else if (isObject(value)) {
+      result[key] = sanitizePayload(value, sensitiveFields);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function extractFields(obj, fields) {
+  const result = {};
+  for (const field of fields) {
+    if (field in obj) {
+      result[field] = obj[field];
+    }
+  }
+  return result;
+}
+function flattenObject(obj, prefix = "") {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (isObject(value) && Object.keys(value).length > 0) {
+      Object.assign(result, flattenObject(value, newKey));
+    } else {
+      result[newKey] = value;
+    }
+  }
+  return result;
+}
+async function retryWithBackoff(fn, options = {}) {
+  const { maxRetries = 3, initialDelay = 100, maxDelay = 5e3, factor = 2 } = options;
+  let lastError;
+  let delay = initialDelay;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === maxRetries) {
+        break;
+      }
+      await sleep(delay);
+      delay = Math.min(delay * factor, maxDelay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+async function processBatch(items, processor, batchSize = 10) {
+  const results = [];
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const result = await processor(batch);
+    results.push(result);
+  }
+  return results;
+}
+function createCache(defaultTtl = 6e4) {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const entry = cache.get(key);
+      if (!entry) return void 0;
+      if (Date.now() > entry.expires) {
+        cache.delete(key);
+        return void 0;
+      }
+      return entry.value;
+    },
+    set(key, value, ttl = defaultTtl) {
+      cache.set(key, { value, expires: Date.now() + ttl });
+    },
+    delete(key) {
+      return cache.delete(key);
+    },
+    clear() {
+      cache.clear();
+    },
+    size() {
+      return cache.size;
+    }
+  };
+}
+
+// src/connectors/mixpanel.connector.ts
+var MixpanelConnector = class extends BaseConnector {
+  constructor(config) {
+    super(config);
+    this.name = "mixpanel";
+    this.type = "analytics";
+    this.token = config.token;
+    this.trackFields = config.trackFields;
+  }
+  async setup() {
+    const Mixpanel = await import('mixpanel');
+    this.client = Mixpanel.init(this.token);
+    this.log("Mixpanel client initialized");
+  }
+  track(event) {
+    if (!this.client) {
+      this.log("Client not initialized");
+      return;
+    }
+    let properties = event.payload;
+    if (this.trackFields && this.trackFields.length > 0) {
+      properties = {};
+      this.trackFields.forEach((field) => {
+        if (event.payload[field] !== void 0) {
+          properties[field] = event.payload[field];
+        }
+      });
+    }
+    const mixpanelProps = {
+      ...properties,
+      distinct_id: event.meta?.userId,
+      time: event.timestamp ? new Date(event.timestamp).getTime() / 1e3 : void 0
+    };
+    this.client.track(event.name, mixpanelProps);
+    this.log("Event tracked", { name: event.name });
+  }
+  identify(event) {
+    if (!this.client) return;
+    this.client.people.set(event.userId, {
+      ...event.traits,
+      $last_seen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.log("User identified", { userId: event.userId });
+  }
+  page(event) {
+    this.track({
+      name: "Page View",
+      payload: { page: event.name, ...event.properties },
+      timestamp: event.timestamp
+    });
+  }
+};
+function createMixpanelConnector(config) {
+  return new MixpanelConnector(config);
+}
+
+// src/connectors/posthog.connector.ts
+var PostHogConnector = class extends BaseConnector {
+  constructor(config) {
+    super(config);
+    this.name = "posthog";
+    this.type = "analytics";
+    this.apiKey = config.apiKey;
+    this.host = config.host || "https://app.posthog.com";
+  }
+  async setup() {
+    const { PostHog } = await import('posthog-node');
+    this.client = new PostHog(this.apiKey, { host: this.host });
+    this.log("PostHog client initialized");
+  }
+  track(event) {
+    if (!this.client) return;
+    this.client.capture({
+      distinctId: event.meta?.userId || event.payload.user_id || "anonymous",
+      event: event.name,
+      properties: event.payload,
+      timestamp: event.timestamp ? new Date(event.timestamp) : void 0
+    });
+    this.log("Event captured", { name: event.name });
+    this.client.flush().catch(() => {
+    });
+  }
+  identify(event) {
+    if (!this.client) return;
+    this.client.identify({
+      distinctId: event.userId,
+      properties: event.traits
+    });
+    this.log("User identified", { userId: event.userId });
+  }
+  page(event) {
+    this.track({
+      name: "$pageview",
+      payload: { $current_url: event.name, ...event.properties },
+      timestamp: event.timestamp
+    });
+  }
+  async shutdown() {
+    await this.client?.shutdown();
+    await super.shutdown();
+  }
+};
+function createPostHogConnector(config) {
+  return new PostHogConnector(config);
+}
+
+export { BaseConnector, CloudWatchEmfConnector, ConsoleConnector, MixpanelConnector, OtelConnector, PostHogConnector, TelemetryRouter, createCache, createCloudWatchEmfConnector, createConnector, createConnectorsFromConfig, createConsoleConnector, createMixpanelConnector, createOtelConnector, createPostHogConnector, createTelemetryRouter, debounce, deepMerge, detectEnvironment, extractFields, extractTraceContext, factoryRegistry, flattenObject, generateEventId, generateSessionId, generateSpanId, generateTraceId, generateTraceparent, getFactory, getRegisteredFactories, getTraceHeaders, getTraceHeadersSync, hasFactory, isObject, parseTraceparent, processBatch, registerFactory, retryWithBackoff, safeStringify, sanitizePayload, sleep, startSpan, validateConfig, withTraceContext };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map