@virtu3d/event-manager 0.2.7

package/dist/browser/index.js

@@ -0,0 +1,1140 @@
+'use strict';
+
+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/browser/otel-browser.connector.ts
+var BrowserOtelConnector = class extends BaseConnector {
+  constructor(config) {
+    super(config);
+    this.name = "otel-browser";
+    this.type = "observability";
+    this.otelConfig = config;
+  }
+  async setup() {
+    try {
+      const [
+        traceWebModule,
+        traceBaseModule,
+        exporterModule,
+        contextZoneModule,
+        resourcesModule,
+        semconvModule,
+        apiModule
+      ] = await Promise.all([
+        import('@opentelemetry/sdk-trace-web'),
+        import('@opentelemetry/sdk-trace-base'),
+        import('@opentelemetry/exporter-trace-otlp-http'),
+        import('@opentelemetry/context-zone'),
+        import('@opentelemetry/resources'),
+        import('@opentelemetry/semantic-conventions'),
+        import('@opentelemetry/api')
+      ]);
+      const { WebTracerProvider } = traceWebModule;
+      const { SimpleSpanProcessor, BatchSpanProcessor } = traceBaseModule;
+      const { OTLPTraceExporter } = exporterModule;
+      const { ZoneContextManager } = contextZoneModule;
+      const resourceFromAttributes = resourcesModule.resourceFromAttributes || ((attrs) => new resourcesModule.Resource(attrs));
+      const ATTR_SERVICE_NAME = semconvModule.ATTR_SERVICE_NAME || semconvModule.SEMRESATTRS_SERVICE_NAME || "service.name";
+      const { trace } = apiModule;
+      const resourceAttrs = {
+        [ATTR_SERVICE_NAME]: this.otelConfig.serviceName,
+        "telemetry.sdk.language": "webjs",
+        "telemetry.sdk.name": "@fountaneengineering/event-manager",
+        ...this.otelConfig.resourceAttributes
+      };
+      const spanProcessors = [];
+      if (this.otelConfig.collectorUrl) {
+        const exporter = new OTLPTraceExporter({
+          url: this.otelConfig.collectorUrl
+        });
+        spanProcessors.push(new BatchSpanProcessor(exporter));
+      } else {
+        spanProcessors.push(
+          new SimpleSpanProcessor({
+            export: (spans, resultCallback) => {
+              if (this.config.debug) {
+                console.log("[otel-browser] Spans:", spans);
+              }
+              resultCallback({ code: 0 });
+            },
+            shutdown: () => Promise.resolve()
+          })
+        );
+      }
+      this.provider = new WebTracerProvider({
+        resource: resourceFromAttributes(resourceAttrs),
+        spanProcessors
+      });
+      this.provider.register({
+        contextManager: new ZoneContextManager()
+      });
+      this.tracer = trace.getTracer(this.otelConfig.serviceName, "1.0.0");
+      this.log("Browser OTEL tracer initialized", {
+        serviceName: this.otelConfig.serviceName,
+        collectorUrl: this.otelConfig.collectorUrl || "none (debug mode)"
+      });
+    } catch (error) {
+      this.log("Failed to initialize OTEL", error);
+      throw error;
+    }
+  }
+  track(event) {
+    if (!this.tracer) {
+      this.log("Tracer not initialized, skipping track");
+      return;
+    }
+    const span = this.tracer.startSpan(event.name);
+    span.setAttribute("event.name", event.name);
+    span.setAttribute("event.timestamp", event.timestamp || (/* @__PURE__ */ new Date()).toISOString());
+    if (event.payload) {
+      Object.entries(event.payload).forEach(([key, value]) => {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          span.setAttribute(`payload.${key}`, value);
+        } else if (value !== null && value !== void 0) {
+          try {
+            span.setAttribute(`payload.${key}`, JSON.stringify(value));
+          } catch {
+          }
+        }
+      });
+    }
+    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) {
+    if (!this.tracer) return;
+    const span = this.tracer.startSpan("user.identify");
+    span.setAttribute("user.id", event.userId);
+    if (event.traits) {
+      Object.entries(event.traits).forEach(([key, value]) => {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          span.setAttribute(`user.traits.${key}`, value);
+        }
+      });
+    }
+    span.end();
+    this.log("User identified", { userId: event.userId });
+  }
+  page(event) {
+    this.track({
+      name: "page_view",
+      payload: {
+        pageName: event.name || window.location.pathname,
+        url: window.location.href,
+        referrer: document.referrer,
+        ...event.properties
+      },
+      timestamp: event.timestamp
+    });
+  }
+  async shutdown() {
+    if (this.provider) {
+      try {
+        await this.provider.shutdown();
+        this.log("Provider shutdown complete");
+      } catch (error) {
+        this.log("Error during shutdown", error);
+      }
+    }
+    await super.shutdown();
+  }
+  /**
+   * Get the underlying tracer for advanced use cases
+   */
+  getTracer() {
+    return this.tracer;
+  }
+  /**
+   * Get the provider for advanced configuration
+   */
+  getProvider() {
+    return this.provider;
+  }
+};
+function createBrowserOtelConnector(config) {
+  return new BrowserOtelConnector(config);
+}
+
+// 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/browser/interceptors.ts
+function matchesPatterns(url, patterns) {
+  return patterns.some((pattern) => {
+    if (typeof pattern === "string") {
+      return url.includes(pattern);
+    }
+    return pattern.test(url);
+  });
+}
+function shouldPropagate(url, includePatterns, excludePatterns) {
+  if (!matchesPatterns(url, includePatterns)) {
+    return false;
+  }
+  if (excludePatterns && excludePatterns.length > 0) {
+    return !matchesPatterns(url, excludePatterns);
+  }
+  return true;
+}
+function createTracedFetch(config) {
+  const originalFetch = config.originalFetch || globalThis.fetch;
+  return async function tracedFetch(input, init) {
+    let url;
+    if (typeof input === "string") {
+      url = input;
+    } else if (input instanceof URL) {
+      url = input.href;
+    } else {
+      url = input.url;
+    }
+    if (!shouldPropagate(url, config.propagateToUrls, config.excludeUrls)) {
+      return originalFetch(input, init);
+    }
+    const traceHeaders = await getTraceHeaders();
+    const headers = new Headers(init?.headers);
+    Object.entries(traceHeaders).forEach(([key, value]) => {
+      if (!headers.has(key)) {
+        headers.set(key, value);
+      }
+    });
+    const newInit = {
+      ...init,
+      headers
+    };
+    if (config.createSpans) {
+      return fetchWithSpan(originalFetch, input, newInit, url, config.serviceName);
+    }
+    return originalFetch(input, newInit);
+  };
+}
+async function fetchWithSpan(originalFetch, input, init, url, serviceName = "browser-fetch") {
+  try {
+    const { trace, SpanStatusCode } = await import('@opentelemetry/api');
+    const tracer = trace.getTracer(serviceName);
+    const parsedUrl = new URL(url, window.location.origin);
+    const spanName = `HTTP ${init.method || "GET"} ${parsedUrl.pathname}`;
+    const span = tracer.startSpan(spanName);
+    try {
+      span.setAttribute("http.method", init.method || "GET");
+      span.setAttribute("http.url", url);
+      span.setAttribute("http.host", parsedUrl.host);
+      span.setAttribute("http.scheme", parsedUrl.protocol.replace(":", ""));
+      const response = await originalFetch(input, init);
+      span.setAttribute("http.status_code", response.status);
+      span.setAttribute("http.response_content_length", response.headers.get("content-length") || 0);
+      if (response.ok) {
+        span.setStatus({ code: SpanStatusCode.OK });
+      } else {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: `HTTP ${response.status} ${response.statusText}`
+        });
+      }
+      return response;
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : "Fetch failed"
+      });
+      span.recordException(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    } finally {
+      span.end();
+    }
+  } catch {
+    return originalFetch(input, init);
+  }
+}
+var storedOriginalFetch = null;
+function installFetchInterceptor(config) {
+  if (typeof globalThis.fetch === "undefined") {
+    console.warn("[@fountaneengineering/event-manager] fetch is not available in this environment");
+    return;
+  }
+  const originalFetch = config.originalFetch || globalThis.fetch;
+  storedOriginalFetch = originalFetch;
+  globalThis.fetch = createTracedFetch({
+    ...config,
+    originalFetch
+  });
+}
+function uninstallFetchInterceptor(originalFetch) {
+  if (typeof globalThis.fetch !== "undefined") {
+    const fetchToRestore = originalFetch || storedOriginalFetch;
+    if (fetchToRestore) {
+      globalThis.fetch = fetchToRestore;
+      storedOriginalFetch = null;
+    }
+  }
+}
+function installXHRInterceptor(config) {
+  if (typeof XMLHttpRequest === "undefined") {
+    console.warn("[@fountaneengineering/event-manager] XMLHttpRequest is not available in this environment");
+    return;
+  }
+  const OriginalXHR = XMLHttpRequest;
+  const originalOpen = OriginalXHR.prototype.open;
+  const originalSend = OriginalXHR.prototype.send;
+  const urlMap = /* @__PURE__ */ new WeakMap();
+  OriginalXHR.prototype.open = function(method, url, async = true, username, password) {
+    const urlString = typeof url === "string" ? url : url.href;
+    urlMap.set(this, urlString);
+    return originalOpen.call(this, method, urlString, async, username, password);
+  };
+  OriginalXHR.prototype.send = async function(body) {
+    const url = urlMap.get(this);
+    if (url && shouldPropagate(url, config.propagateToUrls, config.excludeUrls)) {
+      try {
+        const traceHeaders = await getTraceHeaders();
+        Object.entries(traceHeaders).forEach(([key, value]) => {
+          this.setRequestHeader(key, value);
+        });
+      } catch {
+      }
+    }
+    return originalSend.call(this, body);
+  };
+}
+function createAxiosTraceInterceptor(config) {
+  return async (axiosConfig) => {
+    const url = axiosConfig.url || "";
+    const baseURL = axiosConfig.baseURL || "";
+    const fullUrl = url.startsWith("http") ? url : `${baseURL}${url}`;
+    if (shouldPropagate(fullUrl, config.propagateToUrls, config.excludeUrls)) {
+      const traceHeaders = await getTraceHeaders();
+      axiosConfig.headers = {
+        ...axiosConfig.headers,
+        ...traceHeaders
+      };
+    }
+    return axiosConfig;
+  };
+}
+function installAxiosInterceptor(axiosInstance, config) {
+  return axiosInstance.interceptors.request.use(createAxiosTraceInterceptor(config));
+}
+async function getTracedHeaders(existingHeaders = {}) {
+  const traceHeaders = await getTraceHeaders();
+  return {
+    ...existingHeaders,
+    ...traceHeaders
+  };
+}
+
+// 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
+    });
+  }
+};
+
+// 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("");
+  }
+};
+
+// 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 } = dynamicRequire("../connectors/mixpanel.connector");
+    return new MixpanelConnector(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 } = dynamicRequire("../connectors/posthog.connector");
+    return new PostHogConnector(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/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 debounce(fn, delay) {
+  let timeoutId = null;
+  return (...args) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      fn(...args);
+      timeoutId = null;
+    }, delay);
+  };
+}
+
+// src/browser/index.ts
+registerFactory("otel-browser", (config) => new BrowserOtelConnector(config));
+
+exports.BaseConnector = BaseConnector;
+exports.BrowserOtelConnector = BrowserOtelConnector;
+exports.ConsoleConnector = ConsoleConnector;
+exports.TelemetryRouter = TelemetryRouter;
+exports.createAxiosTraceInterceptor = createAxiosTraceInterceptor;
+exports.createBrowserOtelConnector = createBrowserOtelConnector;
+exports.createConnector = createConnector;
+exports.createConsoleConnector = createConsoleConnector;
+exports.createTelemetryRouter = createTelemetryRouter;
+exports.createTracedFetch = createTracedFetch;
+exports.debounce = debounce;
+exports.deepMerge = deepMerge;
+exports.detectEnvironment = detectEnvironment;
+exports.extractTraceContext = extractTraceContext;
+exports.generateEventId = generateEventId;
+exports.generateSessionId = generateSessionId;
+exports.generateSpanId = generateSpanId;
+exports.generateTraceId = generateTraceId;
+exports.generateTraceparent = generateTraceparent;
+exports.getFactory = getFactory;
+exports.getTraceHeaders = getTraceHeaders;
+exports.getTraceHeadersSync = getTraceHeadersSync;
+exports.getTracedHeaders = getTracedHeaders;
+exports.hasFactory = hasFactory;
+exports.installAxiosInterceptor = installAxiosInterceptor;
+exports.installFetchInterceptor = installFetchInterceptor;
+exports.installXHRInterceptor = installXHRInterceptor;
+exports.isObject = isObject;
+exports.parseTraceparent = parseTraceparent;
+exports.registerFactory = registerFactory;
+exports.safeStringify = safeStringify;
+exports.sanitizePayload = sanitizePayload;
+exports.startSpan = startSpan;
+exports.uninstallFetchInterceptor = uninstallFetchInterceptor;
+exports.withTraceContext = withTraceContext;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map