@grafana/faro-react-native-tracing 1.0.0-alpha.1

package/dist/types/exporters/faroTraceExporter.d.ts

@@ -0,0 +1,21 @@
+import type { ExportResult } from '@opentelemetry/core';
+import type { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+import type { FaroTraceExporterConfig } from '../types';
+/**
+ * FaroTraceExporter for React Native
+ *
+ * Exports OpenTelemetry spans to Faro backend using pushTraces API.
+ *
+ * IMPORTANT: To avoid infinite loops:
+ * - Uses internalLogger instead of console
+ * - Does NOT log during export (except errors)
+ * - Relies on Faro's internal deduplication
+ */
+export declare class FaroTraceExporter implements SpanExporter {
+    private config;
+    private _isShutdown;
+    constructor(config: FaroTraceExporterConfig);
+    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
+    shutdown(): Promise<void>;
+    forceFlush(): Promise<void>;
+}

package/dist/types/exporters/faroTraceExporter.utils.d.ts

@@ -0,0 +1,17 @@
+import { type IResourceSpans } from '@opentelemetry/otlp-transformer/build/src/trace/internal-types';
+/**
+ * Send Faro events for CLIENT spans (HTTP requests, navigation, etc.)
+ *
+ * IMPORTANT: This function is called during trace export and must be careful to avoid infinite loops.
+ *
+ * Infinite loop prevention strategy:
+ * 1. Only process SPAN_KIND_CLIENT spans (HTTP requests, etc.)
+ * 2. Use faro.api.pushEvent which:
+ *    - Does NOT trigger console logs if ConsoleInstrumentation is configured properly
+ *    - Does NOT trigger HTTP instrumentation for collector URLs (they're ignored)
+ * 3. Use internalLogger for debugging instead of console
+ * 4. Never call console.log/warn/error in this function
+ *
+ * @param resourceSpans - OTLP resource spans from trace exporter
+ */
+export declare function sendFaroEvents(resourceSpans?: IResourceSpans[]): void;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { FaroTraceExporter } from './exporters/faroTraceExporter';
+export { getDefaultOTELInstrumentations } from './instrumentations/getDefaultOTELInstrumentations';
+export { TracingInstrumentation } from './instrumentation';
+export { getSamplingDecision } from './utils/sampler';
+export type { FaroTraceExporterConfig, TracingInstrumentationOptions } from './types';
+export { setSpanStatusOnFetchError, fetchCustomAttributeFunctionWithDefaults, } from './instrumentations/instrumentationUtils';
+export { FaroMetaAttributesSpanProcessor } from './processors/faroMetaAttributesSpanProcessor';

package/dist/types/instrumentation.d.ts

@@ -0,0 +1,46 @@
+import { BaseInstrumentation } from '@grafana/faro-core';
+import type { TracingInstrumentationOptions } from './types';
+/**
+ * TracingInstrumentation for React Native
+ *
+ * Enables distributed tracing with OpenTelemetry for React Native applications.
+ *
+ * IMPORTANT: Infinite loop prevention
+ * - Uses internalLogger for debugging instead of console
+ * - Collector URLs are added to ignoreUrls in HTTP instrumentation
+ * - BatchSpanProcessor delays span export to avoid blocking
+ * - No console logging during trace export
+ *
+ * Example usage:
+ * ```ts
+ * import { initializeFaro } from '@grafana/faro-react-native';
+ * import { TracingInstrumentation } from '@grafana/faro-react-native-tracing';
+ *
+ * initializeFaro({
+ *   // ... other config
+ *   instrumentations: [
+ *     new TracingInstrumentation({
+ *       propagateTraceHeaderCorsUrls: [/https:\\/\\/my-api\\.com/],
+ *     }),
+ *   ],
+ * });
+ * ```
+ */
+export declare class TracingInstrumentation extends BaseInstrumentation {
+    private options;
+    name: string;
+    version: string;
+    static SCHEDULED_BATCH_DELAY_MS: number;
+    private provider?;
+    constructor(options?: TracingInstrumentationOptions);
+    initialize(): void;
+    /**
+     * Get ignore URLs from all transports to avoid tracing collector requests
+     * CRITICAL: This prevents infinite loops where trace exports trigger more traces
+     */
+    private getIgnoreUrls;
+    /**
+     * Shutdown the tracer provider
+     */
+    shutdown(): Promise<void>;
+}

package/dist/types/instrumentations/getDefaultOTELInstrumentations.d.ts

@@ -0,0 +1,17 @@
+import type { DefaultInstrumentationsOptions, InstrumentationOption } from '../types';
+/**
+ * Get default OTEL instrumentations for React Native
+ *
+ * This function creates the default OpenTelemetry instrumentations for React Native:
+ * - FetchInstrumentation: Traces fetch() API calls
+ * - XMLHttpRequestInstrumentation: Traces XMLHttpRequest and axios (which uses XHR)
+ *
+ * IMPORTANT: Infinite loop prevention
+ * - ignoreUrls is used to exclude Faro collector URLs
+ * - ignoreNetworkEvents is true to avoid duplicate events
+ * - No console logging during instrumentation
+ *
+ * @param options - Configuration options
+ * @returns Array of OTEL instrumentations
+ */
+export declare function getDefaultOTELInstrumentations(options?: DefaultInstrumentationsOptions): InstrumentationOption[];

package/dist/types/instrumentations/instrumentationUtils.d.ts

@@ -0,0 +1,26 @@
+import type { Span } from '@opentelemetry/api';
+import type { FetchCustomAttributeFunction } from '@opentelemetry/instrumentation-fetch';
+import type { XHRCustomAttributeFunction } from '@opentelemetry/instrumentation-xml-http-request';
+/**
+ * Set span status to ERROR when fetch fails
+ *
+ * This ensures that failed HTTP requests are marked as errors in traces.
+ */
+export declare function setSpanStatusOnFetchError(span: Span, error: Error | string): void;
+/**
+ * Custom attribute function for fetch instrumentation with defaults
+ *
+ * Combines user-provided custom attributes with default handling.
+ *
+ * @param userFunction - Optional user-provided custom attribute function
+ * @returns Combined custom attribute function
+ */
+export declare function fetchCustomAttributeFunctionWithDefaults(userFunction?: FetchCustomAttributeFunction): FetchCustomAttributeFunction;
+/**
+ * Set span status to ERROR for XHR failures (status 0 or 4xx/5xx).
+ */
+export declare function setSpanStatusOnXMLHttpRequestError(span: Span, xhr: XMLHttpRequest): void;
+/**
+ * Custom attribute function for XHR instrumentation with defaults.
+ */
+export declare function xhrCustomAttributeFunctionWithDefaults(userFunction?: XHRCustomAttributeFunction): XHRCustomAttributeFunction;

package/dist/types/processors/faroMetaAttributesSpanProcessor.d.ts

@@ -0,0 +1,22 @@
+import type { Context } from '@opentelemetry/api';
+import type { ReadableSpan, Span, SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import type { Metas } from '@grafana/faro-core';
+/**
+ * Span processor that adds Faro meta attributes to spans
+ *
+ * This processor enriches spans with:
+ * - Session ID
+ * - User information (email, id, username, etc.)
+ *
+ * IMPORTANT: This processor delegates to a wrapped processor and does NOT log
+ * to avoid infinite loops.
+ */
+export declare class FaroMetaAttributesSpanProcessor implements SpanProcessor {
+    private processor;
+    private metas;
+    constructor(processor: SpanProcessor, metas: Metas);
+    forceFlush(): Promise<void>;
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+}

package/dist/types/processors/httpRequestMonitorSpanProcessor.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '@opentelemetry/api';
+import type { ReadableSpan, Span, SpanProcessor } from '@opentelemetry/sdk-trace-base';
+/**
+ * SpanProcessor that notifies httpRequestMonitor when HTTP spans start and end.
+ *
+ * This enables user action correlation (UserActionController halt logic) when
+ * TracingInstrumentation is used instead of HttpInstrumentation.
+ *
+ * IMPORTANT: Must not use console or trigger any instrumentation to avoid loops.
+ */
+export declare class HttpRequestMonitorSpanProcessor implements SpanProcessor {
+    private readonly processor;
+    constructor(processor: SpanProcessor);
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/types/semconv.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Semantic convention attributes for React Native tracing
+ * Based on OpenTelemetry semantic conventions with React Native-specific additions
+ */
+export declare const ATTR_SESSION_ID = "session.id";
+export declare const ATTR_DEVICE_MODEL = "device.model";
+export declare const ATTR_DEVICE_BRAND = "device.brand";
+export declare const ATTR_DEVICE_PLATFORM = "device.platform";
+export declare const ATTR_DEVICE_OS_VERSION = "device.os.version";
+export declare const ATTR_DEVICE_TYPE = "device.type";
+export declare const ATTR_DEVICE_LOCALE = "device.locale";
+export declare const ATTR_APP_VERSION = "app.version";
+export declare const ATTR_APP_BUILD = "app.build";
+export declare const ATTR_SERVICE_NAMESPACE = "service.namespace";
+export declare const ATTR_DEPLOYMENT_ENVIRONMENT_NAME = "deployment.environment.name";
+export declare const ATTR_TELEMETRY_DISTRO_NAME = "telemetry.distro.name";
+export declare const ATTR_TELEMETRY_DISTRO_VERSION = "telemetry.distro.version";
+export declare const ATTR_PROCESS_RUNTIME_NAME = "process.runtime.name";
+export declare const ATTR_PROCESS_RUNTIME_VERSION = "process.runtime.version";

package/dist/types/types.d.ts

@@ -0,0 +1,31 @@
+import type { Attributes, ContextManager, TextMapPropagator } from '@opentelemetry/api';
+import type { Instrumentation } from '@opentelemetry/instrumentation';
+import type { FetchCustomAttributeFunction } from '@opentelemetry/instrumentation-fetch';
+import type { XHRCustomAttributeFunction } from '@opentelemetry/instrumentation-xml-http-request';
+import type { SpanProcessor } from '@opentelemetry/sdk-trace-base';
+import type { API, Patterns } from '@grafana/faro-core';
+export type InstrumentationOption = Instrumentation | Instrumentation[];
+export interface FaroTraceExporterConfig {
+    api: API;
+}
+export interface TracingInstrumentationOptions {
+    resourceAttributes?: Attributes;
+    propagator?: TextMapPropagator;
+    contextManager?: ContextManager;
+    instrumentations?: InstrumentationOption[];
+    spanProcessor?: SpanProcessor;
+    instrumentationOptions?: Omit<DefaultInstrumentationsOptions, 'ignoreUrls'>;
+}
+export type MatchUrlDefinitions = Patterns;
+export type DefaultInstrumentationsOptions = {
+    ignoreUrls?: MatchUrlDefinitions;
+    propagateTraceHeaderCorsUrls?: MatchUrlDefinitions;
+    fetchInstrumentationOptions?: {
+        applyCustomAttributesOnSpan?: FetchCustomAttributeFunction;
+        ignoreNetworkEvents?: boolean;
+    };
+    xhrInstrumentationOptions?: {
+        applyCustomAttributesOnSpan?: XHRCustomAttributeFunction;
+        ignoreNetworkEvents?: boolean;
+    };
+};

package/dist/types/utils/sampler.d.ts

@@ -0,0 +1,12 @@
+import { SamplingDecision } from '@opentelemetry/sdk-trace-base';
+import type { MetaSession } from '@grafana/faro-core';
+/**
+ * Get sampling decision based on session configuration
+ *
+ * If the session is sampled, traces will be collected.
+ * If the session is not sampled, traces will be dropped.
+ *
+ * @param sessionMeta - Current Faro session meta
+ * @returns OTEL sampling decision
+ */
+export declare function getSamplingDecision(sessionMeta?: MetaSession): SamplingDecision;

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@grafana/faro-react-native-tracing",
+  "version": "1.0.0-alpha.1",
+  "description": "Faro React Native tracing implementation with OpenTelemetry.",
+  "keywords": [
+    "observability",
+    "apm",
+    "rum",
+    "logs",
+    "traces",
+    "metrics",
+    "react-native",
+    "mobile",
+    "opentelemetry"
+  ],
+  "license": "Apache-2.0",
+  "author": "Grafana Labs",
+  "homepage": "https://github.com/grafana/faro-react-native-sdk",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/grafana/faro-react-native-sdk.git",
+    "directory": "packages/react-native-tracing"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "react-native": "./src/index.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "yarn watch",
+    "build": "run-s 'build:*'",
+    "build:compile": "run-p 'build:compile:*'",
+    "build:compile:cjs": "tsc --build tsconfig.cjs.json",
+    "build:compile:esm": "tsc --build tsconfig.esm.json",
+    "watch": "run-p 'watch:compile:*'",
+    "watch:compile:cjs": "yarn build:compile:cjs -w",
+    "watch:compile:esm": "yarn build:compile:esm -w",
+    "clean": "rimraf dist/ yarn-error.log",
+    "quality": "run-s 'quality:*'",
+    "quality:test": "../../node_modules/.bin/jest",
+    "quality:format": "prettier --cache --cache-location=../../.cache/prettier/reactNativeTracing --ignore-path ../../.prettierignore -w \"./**/*.{js,jsx,ts,tsx,css,scss,md,yaml,yml,json}\"",
+    "quality:lint": "run-p 'quality:lint:eslint' 'quality:lint:prettier'",
+    "quality:lint:eslint": "eslint --cache --cache-location ../../.cache/eslint/reactNativeTracing \"./**/*.{js,jsx,ts,tsx}\"",
+    "quality:lint:prettier": "prettier --cache --cache-location=../../.cache/prettier/reactNativeTracing --ignore-path ../../.prettierignore -c \"./**/*.{js,jsx,ts,tsx,css,scss,md,yaml,yml,json}\"",
+    "quality:circular-deps": "madge --circular ."
+  },
+  "dependencies": {
+    "@grafana/faro-core": "^2.2.3",
+    "@grafana/faro-react-native": "^1.0.0-alpha.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.0.0",
+    "@opentelemetry/instrumentation": "^0.208.0",
+    "@opentelemetry/instrumentation-fetch": "^0.208.0",
+    "@opentelemetry/instrumentation-xml-http-request": "^0.208.0",
+    "@opentelemetry/otlp-transformer": "^0.208.0",
+    "@opentelemetry/resources": "^2.0.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.0",
+    "@opentelemetry/semantic-conventions": "^1.32.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.70.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.1",
+    "@types/react-native": "^0.73.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "8735c51051a17ebaabe49d5d65d729ebda3fa733"
+}

package/src/exporters/faroTraceExporter.test.ts

@@ -0,0 +1,110 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import { BasicTracerProvider, ReadableSpan } from '@opentelemetry/sdk-trace-base';
+
+import { initializeFaro } from '@grafana/faro-core';
+import { mockConfig, MockTransport } from '@grafana/faro-test-utils';
+
+import { FaroTraceExporter } from './faroTraceExporter';
+
+describe('FaroTraceExporter', () => {
+  let transport: MockTransport;
+  let provider: BasicTracerProvider;
+  let faro: any;
+  let consoleErrorSpy: jest.SpiedFunction<typeof console.error>;
+
+  beforeEach(() => {
+    // internalLogger.error forwards here; expected-error tests should not spam CI output
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    transport = new MockTransport();
+    faro = initializeFaro(
+      mockConfig({
+        transports: [transport],
+      })
+    );
+    provider = new BasicTracerProvider();
+  });
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore();
+    transport.items = [];
+  });
+
+  it('should export spans successfully', (done) => {
+    const exporter = new FaroTraceExporter({ api: faro.api });
+
+    const tracer = provider.getTracer('test');
+    const span = tracer.startSpan('test-span');
+    span.end();
+
+    const readableSpan = span as any as ReadableSpan;
+
+    exporter.export([readableSpan], (result) => {
+      expect(result.code).toBe(ExportResultCode.SUCCESS);
+      done();
+    });
+  });
+
+  it('should call api.pushTraces', (done) => {
+    const pushTracesSpy = jest.spyOn(faro.api, 'pushTraces');
+    const exporter = new FaroTraceExporter({ api: faro.api });
+
+    const tracer = provider.getTracer('test');
+    const span = tracer.startSpan('test-span');
+    span.end();
+
+    const readableSpan = span as any as ReadableSpan;
+
+    exporter.export([readableSpan], (result) => {
+      expect(pushTracesSpy).toHaveBeenCalled();
+      expect(result.code).toBe(ExportResultCode.SUCCESS);
+      done();
+    });
+  });
+
+  it('should return FAILED when exporter is shutdown', (done) => {
+    const exporter = new FaroTraceExporter({ api: faro.api });
+
+    exporter.shutdown();
+
+    const tracer = provider.getTracer('test');
+    const span = tracer.startSpan('test-span');
+    span.end();
+
+    const readableSpan = span as any as ReadableSpan;
+
+    exporter.export([readableSpan], (result) => {
+      expect(result.code).toBe(ExportResultCode.FAILED);
+      done();
+    });
+  });
+
+  it('should handle export errors gracefully', (done) => {
+    jest.spyOn(faro.api, 'pushTraces').mockImplementation(() => {
+      throw new Error('Export failed');
+    });
+    const exporter = new FaroTraceExporter({ api: faro.api });
+
+    const tracer = provider.getTracer('test');
+    const span = tracer.startSpan('test-span');
+    span.end();
+
+    const readableSpan = span as any as ReadableSpan;
+
+    exporter.export([readableSpan], (result) => {
+      expect(result.code).toBe(ExportResultCode.FAILED);
+      done();
+    });
+  });
+
+  it('should resolve shutdown promise', async () => {
+    const exporter = new FaroTraceExporter({ api: faro.api });
+
+    await expect(exporter.shutdown()).resolves.toBeUndefined();
+  });
+
+  it('should resolve forceFlush promise', async () => {
+    const exporter = new FaroTraceExporter({ api: faro.api });
+
+    await expect(exporter.forceFlush()).resolves.toBeUndefined();
+  });
+});

package/src/exporters/faroTraceExporter.ts

@@ -0,0 +1,64 @@
+import { ExportResultCode } from '@opentelemetry/core';
+import type { ExportResult } from '@opentelemetry/core';
+import { createExportTraceServiceRequest } from '@opentelemetry/otlp-transformer/build/src/trace/internal';
+import type { ReadableSpan, SpanExporter } from '@opentelemetry/sdk-trace-base';
+
+import { createInternalLogger } from '@grafana/faro-core';
+
+const internalLogger = createInternalLogger();
+
+import type { FaroTraceExporterConfig } from '../types';
+
+import { sendFaroEvents } from './faroTraceExporter.utils';
+
+/**
+ * FaroTraceExporter for React Native
+ *
+ * Exports OpenTelemetry spans to Faro backend using pushTraces API.
+ *
+ * IMPORTANT: To avoid infinite loops:
+ * - Uses internalLogger instead of console
+ * - Does NOT log during export (except errors)
+ * - Relies on Faro's internal deduplication
+ */
+export class FaroTraceExporter implements SpanExporter {
+  private _isShutdown = false;
+
+  constructor(private config: FaroTraceExporterConfig) {}
+
+  export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void {
+    if (this._isShutdown) {
+      internalLogger.error('FaroTraceExporter: Cannot export spans, exporter is shut down');
+      resultCallback({ code: ExportResultCode.FAILED });
+      return;
+    }
+
+    try {
+      // Convert spans to OTLP format
+      const traceEvent = createExportTraceServiceRequest(spans, { useHex: true, useLongBits: false });
+
+      // Send traces to Faro
+      this.config.api.pushTraces(traceEvent);
+
+      // Send Faro events for CLIENT spans (HTTP requests, etc.)
+      // This is done WITHOUT logging to avoid infinite loops
+      sendFaroEvents(traceEvent.resourceSpans);
+
+      resultCallback({ code: ExportResultCode.SUCCESS });
+    } catch (error) {
+      // Only log critical errors
+      internalLogger.error('FaroTraceExporter: Failed to export spans', error);
+      resultCallback({ code: ExportResultCode.FAILED });
+    }
+  }
+
+  async shutdown(): Promise<void> {
+    this._isShutdown = true;
+    return Promise.resolve(undefined);
+  }
+
+  async forceFlush(): Promise<void> {
+    // No-op for now - spans are sent immediately via pushTraces
+    return Promise.resolve(undefined);
+  }
+}

package/src/exporters/faroTraceExporter.utils.ts

@@ -0,0 +1,105 @@
+import type { SpanContext } from '@opentelemetry/api';
+import { ESpanKind, type IResourceSpans } from '@opentelemetry/otlp-transformer/build/src/trace/internal-types';
+
+import { createInternalLogger, faro, unknownString } from '@grafana/faro-core';
+import type { EventAttributes as FaroEventAttributes } from '@grafana/faro-core';
+
+const internalLogger = createInternalLogger();
+
+const DURATION_NS_KEY = 'duration_ns';
+
+/**
+ * Send Faro events for CLIENT spans (HTTP requests, navigation, etc.)
+ *
+ * IMPORTANT: This function is called during trace export and must be careful to avoid infinite loops.
+ *
+ * Infinite loop prevention strategy:
+ * 1. Only process SPAN_KIND_CLIENT spans (HTTP requests, etc.)
+ * 2. Use faro.api.pushEvent which:
+ *    - Does NOT trigger console logs if ConsoleInstrumentation is configured properly
+ *    - Does NOT trigger HTTP instrumentation for collector URLs (they're ignored)
+ * 3. Use internalLogger for debugging instead of console
+ * 4. Never call console.log/warn/error in this function
+ *
+ * @param resourceSpans - OTLP resource spans from trace exporter
+ */
+export function sendFaroEvents(resourceSpans: IResourceSpans[] = []) {
+  try {
+    for (const resourceSpan of resourceSpans) {
+      const { scopeSpans } = resourceSpan;
+
+      for (const scopeSpan of scopeSpans) {
+        const { scope, spans = [] } = scopeSpan;
+
+        for (const span of spans) {
+          // Only process CLIENT spans (HTTP requests, external calls)
+          // This avoids processing internal spans which could cause loops
+          if (span.kind !== ESpanKind.SPAN_KIND_CLIENT) {
+            continue;
+          }
+
+          const spanContext: Pick<SpanContext, 'traceId' | 'spanId'> = {
+            traceId: span.traceId.toString(),
+            spanId: span.spanId.toString(),
+          };
+
+          const faroEventAttributes: FaroEventAttributes = {};
+          for (const attribute of span.attributes) {
+            faroEventAttributes[attribute.key] = String(Object.values(attribute.value)[0]);
+          }
+
+          // Add span duration in nanoseconds
+          if (!Number.isNaN(span.endTimeUnixNano) && !Number.isNaN(span.startTimeUnixNano)) {
+            faroEventAttributes[DURATION_NS_KEY] = String(
+              Number(span.endTimeUnixNano) - Number(span.startTimeUnixNano)
+            );
+          }
+
+          const index = (scope?.name ?? '').indexOf('-');
+          let eventName = unknownString;
+
+          if (scope?.name) {
+            if (index === -1) {
+              eventName = scope.name.split('/')[1] ?? scope.name;
+            }
+
+            if (index > -1) {
+              eventName = scope?.name.substring(index + 1);
+            }
+          }
+
+          // Push event to Faro
+          // This should NOT cause infinite loops because:
+          // 1. The collector URL is in ignoreUrls for HttpInstrumentation
+          // 2. ConsoleInstrumentation won't log this event
+          // 3. No console.log calls are made here
+          faro.api.pushEvent(`faro.tracing.${eventName}`, faroEventAttributes, undefined, {
+            spanContext,
+            // Convert nanoseconds to milliseconds
+            timestampOverwriteMs: Number(span.endTimeUnixNano) / 1_000_000,
+            customPayloadTransformer: (payload) => {
+              if (
+                faroEventAttributes['faro.action.user.name'] != null &&
+                faroEventAttributes['faro.action.user.parentId'] != null
+              ) {
+                payload.action = {
+                  name: faroEventAttributes['faro.action.user.name'],
+                  parentId: faroEventAttributes['faro.action.user.parentId'],
+                };
+
+                delete payload.attributes?.['faro.action.user.name'];
+                delete payload.attributes?.['faro.action.user.parentId'];
+              }
+
+              return payload;
+            },
+          });
+        }
+      }
+    }
+  } catch (error) {
+    // Only log critical errors using internal logger
+    // Do NOT use console.log here as it could cause infinite loops
+    internalLogger.error('sendFaroEvents: Failed to process spans', error);
+  }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export { FaroTraceExporter } from './exporters/faroTraceExporter';
+
+export { getDefaultOTELInstrumentations } from './instrumentations/getDefaultOTELInstrumentations';
+
+export { TracingInstrumentation } from './instrumentation';
+
+export { getSamplingDecision } from './utils/sampler';
+
+export type { FaroTraceExporterConfig, TracingInstrumentationOptions } from './types';
+
+export {
+  setSpanStatusOnFetchError,
+  fetchCustomAttributeFunctionWithDefaults,
+} from './instrumentations/instrumentationUtils';
+
+export { FaroMetaAttributesSpanProcessor } from './processors/faroMetaAttributesSpanProcessor';