@dreamhorizonorg/pulse-react-native 0.0.1

package/src/errorHandler.ts

@@ -0,0 +1,169 @@
+import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { mergeWithGlobalAttributes } from './globalAttributes';
+import { isSupportedPlatform } from './initialization';
+import { extractErrorDetails } from './utility';
+import type { PulseAttributes } from './pulse.interface';
+
+let previousErrorHandler: ((error: Error, isFatal?: boolean) => void) | null =
+  null;
+
+let isInitialized = false;
+let handlingFatal = false;
+
+function reportToOpenTelemetry(
+  errorMessage: string,
+  stackTrace: string,
+  isFatal: boolean,
+  errorType: string,
+  attributes?: PulseAttributes
+): void {
+  const observedTimeMs = Date.now();
+  const mergedAttributes = mergeWithGlobalAttributes(attributes || {});
+  PulseReactNativeOtel.reportException(
+    errorMessage,
+    observedTimeMs,
+    stackTrace,
+    isFatal,
+    errorType,
+    mergedAttributes
+  );
+}
+
+function handleGlobalError(error: Error, isFatal?: boolean): void {
+  const shouldHandleFatal = !!isFatal;
+  if (shouldHandleFatal) {
+    if (handlingFatal) {
+      PulseReactNativeOtel.trackEvent(
+        'Encountered multiple fatal errors. The latest:',
+        Date.now(),
+        {
+          message: error.message,
+        }
+      );
+      return;
+    }
+    handlingFatal = true;
+  }
+
+  const { message, stackTrace, errorType } = extractErrorDetails(error);
+  reportToOpenTelemetry(message, stackTrace, isFatal || false, errorType);
+  console.error('[Pulse RN Crash]', 'Fatal:', isFatal, 'Error:', error);
+  if (previousErrorHandler && typeof previousErrorHandler === 'function') {
+    try {
+      if (isFatal) {
+        setTimeout(() => {
+          previousErrorHandler!(error, isFatal);
+        }, 150);
+      } else {
+        previousErrorHandler(error, isFatal);
+      }
+    } catch (handlerError) {
+      console.error('[Pulse RN] Previous error handler threw:', handlerError);
+    }
+  }
+}
+
+export function reportException(
+  error: Error | string,
+  isFatal: boolean = false,
+  attributes?: PulseAttributes
+): void {
+  if (!isSupportedPlatform()) {
+    return;
+  }
+
+  let errorMessage: string;
+  let stackTrace: string;
+  let errorType: string;
+
+  if (typeof error === 'string') {
+    errorMessage = error;
+    stackTrace = '';
+    errorType = '';
+  } else {
+    const details = extractErrorDetails(error);
+    errorMessage = details.message;
+    stackTrace = details.stackTrace;
+    errorType = details.errorType;
+  }
+
+  reportToOpenTelemetry(
+    errorMessage,
+    stackTrace,
+    isFatal,
+    errorType,
+    attributes
+  );
+}
+
+function initializeErrorHandler(): void {
+  if (isInitialized) {
+    console.warn('[Pulse RN] Error handler already initialized. Skipping.');
+    return;
+  }
+  handlingFatal = false;
+
+  if (!ErrorUtils) {
+    console.warn(
+      '[Pulse RN] ErrorUtils not available; cannot install global error handler.'
+    );
+    PulseReactNativeOtel.trackEvent(
+      'ErrorUtils not found. Cannot install global error handler.',
+      Date.now()
+    );
+    return;
+  }
+
+  const currentHandler = ErrorUtils.getGlobalHandler?.();
+
+  if (currentHandler) {
+    previousErrorHandler = currentHandler;
+    console.log(
+      '[Pulse RN] Previous error handler detected (likely React Native default) - will be preserved'
+    );
+  } else {
+    console.log(
+      '[Pulse RN] No previous error handler detected (unusual in React Native)'
+    );
+  }
+
+  ErrorUtils.setGlobalHandler(handleGlobalError);
+
+  isInitialized = true;
+  handlingFatal = false;
+
+  console.log('[Pulse RN] Error handler initialized successfully');
+}
+
+function disableErrorHandler(): void {
+  if (!isInitialized) {
+    console.warn(
+      '[Pulse RN] Error handler not initialized. Nothing to disable.'
+    );
+    return;
+  }
+
+  if (previousErrorHandler) {
+    ErrorUtils.setGlobalHandler(previousErrorHandler);
+    console.log(
+      '[Pulse RN] Error handler disabled. Previous handler restored.'
+    );
+  } else {
+    ErrorUtils.setGlobalHandler(null as any);
+    console.log(
+      '[Pulse RN] Error handler disabled. Restored to React Native default.'
+    );
+  }
+
+  isInitialized = false;
+  previousErrorHandler = null;
+  handlingFatal = false;
+}
+
+export function setupErrorHandler(enableErrorHandler: boolean): void {
+  if (enableErrorHandler) {
+    initializeErrorHandler();
+  } else {
+    disableErrorHandler();
+  }
+}

package/src/events.ts

@@ -0,0 +1,15 @@
+import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { mergeWithGlobalAttributes } from './globalAttributes';
+import { isSupportedPlatform } from './initialization';
+import type { PulseAttributes } from './pulse.interface';
+
+export function trackEvent(event: string, attributes?: PulseAttributes): void {
+  if (!isSupportedPlatform()) {
+    return;
+  }
+
+  const observedTimeMs = Date.now();
+  const mergedAttributes = mergeWithGlobalAttributes(attributes || {});
+
+  PulseReactNativeOtel.trackEvent(event, observedTimeMs, mergedAttributes);
+}

package/src/global.d.ts

@@ -0,0 +1,9 @@
+declare global {
+  interface PerformanceLike {
+    now(): number;
+  }
+  var performance: PerformanceLike | undefined;
+}
+
+export {};
+

package/src/globalAttributes.ts

@@ -0,0 +1,16 @@
+import type { PulseAttributes, PulseAttributeValue } from './pulse.interface';
+
+const globalAttributes: PulseAttributes = {};
+
+export function setGlobalAttribute(
+  key: string,
+  value: PulseAttributeValue
+): void {
+  globalAttributes[key] = value;
+}
+
+export function mergeWithGlobalAttributes<T extends PulseAttributes>(
+  attributes?: T
+): T & PulseAttributes {
+  return { ...globalAttributes, ...attributes } as T & PulseAttributes;
+}

package/src/index.tsx

@@ -0,0 +1,35 @@
+import { startSpan, trackSpan } from './trace';
+import { reportException } from './errorHandler';
+import { trackEvent } from './events';
+import { start, createNavigationIntegrationWithConfig } from './config';
+import { isInitialized } from './initialization';
+import { setGlobalAttribute } from './globalAttributes';
+import { setUserId, setUserProperty, setUserProperties } from './user';
+import { ErrorBoundary, withErrorBoundary } from './errorBoundary';
+
+export type { Span } from './trace';
+export type { PulseConfig, PulseStartOptions } from './config';
+export type { PulseAttributes, PulseAttributeValue } from './pulse.interface';
+export type {
+  ReactNavigationIntegration,
+  NavigationRoute,
+} from './reactNavigation';
+
+export type { ErrorBoundaryProps, FallbackRender } from './errorBoundary';
+
+export { SpanStatusCode } from './trace';
+export const Pulse = {
+  start,
+  isInitialized,
+  createNavigationIntegration: createNavigationIntegrationWithConfig,
+  trackEvent,
+  reportException,
+  trackSpan,
+  startSpan,
+  setGlobalAttribute,
+  setUserId,
+  setUserProperty,
+  setUserProperties,
+  ErrorBoundary,
+  withErrorBoundary,
+};

package/src/initialization.ts

@@ -0,0 +1,18 @@
+import { Platform } from 'react-native';
+import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+
+let cachedInitStatus: boolean = false;
+
+export function isInitialized(): boolean {
+  if (!isSupportedPlatform()) {
+    return false;
+  }
+  if (!cachedInitStatus) {
+    cachedInitStatus = PulseReactNativeOtel.isInitialized();
+  }
+  return cachedInitStatus;
+}
+
+export function isSupportedPlatform(): boolean {
+  return Platform.OS === 'android';
+}

package/src/network-interceptor/initialization.ts

@@ -0,0 +1,28 @@
+import createXmlHttpRequestTracker from './request-tracker-xhr';
+
+let isInitialized = false;
+
+export function initializeNetworkInterceptor(): void {
+  if (isInitialized) {
+    console.warn('[Pulse] Network interceptor already initialized');
+    return;
+  }
+
+  console.log('[Pulse] 🔄 Starting network interceptor initialization...');
+
+  try {
+    // In react-native, we are intercepting XMLHttpRequest only, since axios and fetch both use it internally.
+    // See: https://github.com/facebook/react-native/blob/main/packages/react-native/Libraries/Network/fetch.js
+    if (typeof XMLHttpRequest !== 'undefined') {
+      createXmlHttpRequestTracker(XMLHttpRequest);
+    } else {
+      console.warn('[Pulse] XMLHttpRequest is not available');
+    }
+
+    isInitialized = true;
+  } catch (error) {
+    console.error('[Pulse] Failed to initialize network interceptor:', error);
+  }
+}
+
+export const isNetworkInterceptorInitialized = (): boolean => isInitialized;

package/src/network-interceptor/network.interface.ts

@@ -0,0 +1,36 @@
+export interface RequestStartContext {
+  url: string;
+  method: string;
+  type: 'fetch' | 'xmlhttprequest';
+  baseUrl?: string;
+}
+
+export interface RequestEndContextSuccess {
+  status: number;
+  state: 'success';
+}
+
+export interface RequestEndContextError {
+  state: 'error';
+  status?: number;
+  error?: Error;
+}
+
+export type RequestEndContext =
+  | RequestEndContextSuccess
+  | RequestEndContextError;
+
+export type RequestStartCallback = (
+  context: RequestStartContext
+) => { onRequestEnd?: RequestEndCallback } | undefined;
+
+export type RequestEndCallback = (context: RequestEndContext) => void;
+
+export interface NetworkRequestInfo {
+  url: string;
+  method: string;
+  type: 'fetch' | 'xmlhttprequest';
+  status?: number;
+  state: 'success' | 'error';
+  error?: Error;
+}

package/src/network-interceptor/request-tracker-fetch.ts

@@ -0,0 +1,96 @@
+import type {
+  RequestStartContext,
+  RequestEndContext,
+} from './network.interface';
+import { RequestTracker } from './request-tracker';
+import { getAbsoluteUrl } from '../utility';
+import { createNetworkSpan, completeNetworkSpan } from './span-helpers';
+
+interface GlobalWithFetch {
+  fetch: typeof fetch;
+}
+
+function createStartContext(
+  input: unknown,
+  init?: unknown
+): RequestStartContext {
+  const inputIsRequest = isRequest(input);
+  const url = inputIsRequest ? input.url : String(input);
+  const method =
+    (!!init && (init as RequestInit).method) ||
+    (inputIsRequest && input.method) ||
+    'GET';
+  return { url: getAbsoluteUrl(url), method, type: 'fetch' };
+}
+
+function isRequest(input: unknown): input is Request {
+  return !!input && typeof input === 'object' && !(input instanceof URL);
+}
+
+let isFetchIntercepted = false;
+let originalFetch: typeof fetch | null = null;
+
+function createFetchRequestTracker(global: GlobalWithFetch): RequestTracker {
+  if (isFetchIntercepted) {
+    console.warn('[Pulse] Fetch already intercepted');
+    return new RequestTracker();
+  }
+
+  if (originalFetch && global.fetch !== originalFetch) {
+    console.warn('[Pulse] Fetch already wrapped by another interceptor');
+    isFetchIntercepted = true;
+    return new RequestTracker();
+  }
+
+  if ((global.fetch as any)?._pulseIntercepted) {
+    console.warn('[Pulse] Fetch already wrapped by Pulse');
+    isFetchIntercepted = true;
+    return new RequestTracker();
+  }
+
+  const requestTracker = new RequestTracker();
+  originalFetch = global.fetch;
+  isFetchIntercepted = true;
+
+  const fetchWrapper = function fetch(input: unknown, init?: unknown) {
+    const startContext = createStartContext(input, init);
+
+    const span = createNetworkSpan(startContext, 'fetch');
+    const { onRequestEnd } = requestTracker.start(startContext);
+
+    const fetchToCall = originalFetch!;
+    return fetchToCall
+      .call(global, input as RequestInfo, init as RequestInit)
+      .then((response) => {
+        // Determine if response is successful based on status code
+        // 2xx and 3xx are successful, 4xx and 5xx are errors
+        const isSuccess = response.status >= 200 && response.status < 400;
+
+        const endContext: RequestEndContext = {
+          status: response.status,
+          state: isSuccess ? 'success' : 'error',
+        };
+
+        completeNetworkSpan(span, startContext, endContext, !isSuccess);
+        onRequestEnd(endContext);
+        return response;
+      })
+      .catch((error) => {
+        const endContext: RequestEndContext = {
+          error,
+          state: 'error',
+        };
+
+        completeNetworkSpan(span, startContext, endContext, true);
+        onRequestEnd(endContext);
+        throw error;
+      });
+  };
+
+  (fetchWrapper as any)._pulseIntercepted = true;
+  global.fetch = fetchWrapper;
+
+  return requestTracker;
+}
+
+export default createFetchRequestTracker;

package/src/network-interceptor/request-tracker-xhr.ts

@@ -0,0 +1,108 @@
+import type {
+  RequestStartContext,
+  RequestEndContext,
+} from './network.interface';
+import { RequestTracker } from './request-tracker';
+import { getAbsoluteUrl } from '../utility';
+import type { Span } from '../index';
+import { createNetworkSpan, completeNetworkSpan } from './span-helpers';
+
+interface RequestData {
+  method: string;
+  url: string;
+}
+
+type ReadyStateChangeHandler = (this: XMLHttpRequest, ev: Event) => any;
+
+let isXHRIntercepted = false;
+
+function createXmlHttpRequestTracker(
+  xhr: typeof XMLHttpRequest
+): RequestTracker {
+  if (isXHRIntercepted) {
+    console.warn('[Pulse] XMLHttpRequest already intercepted');
+    return new RequestTracker();
+  }
+
+  const requestTracker = new RequestTracker();
+  const trackedRequests = new WeakMap<XMLHttpRequest, RequestData>();
+  const trackedSpans = new WeakMap<XMLHttpRequest, Span>();
+  const requestHandlers = new WeakMap<
+    XMLHttpRequest,
+    ReadyStateChangeHandler
+  >();
+
+  const originalOpen = xhr.prototype.open;
+  xhr.prototype.open = function open(
+    method: string,
+    url: string | URL,
+    ...rest: any[]
+  ): void {
+    trackedRequests.set(this, {
+      method,
+      url: getAbsoluteUrl(String(url)),
+    });
+
+    // @ts-expect-error rest
+    originalOpen.call(this, method, url, ...rest);
+  };
+  isXHRIntercepted = true;
+
+  const originalSend = xhr.prototype.send;
+  xhr.prototype.send = function send(
+    body?: Document | XMLHttpRequestBodyInit | null
+  ) {
+    const requestData = trackedRequests.get(this);
+    if (requestData) {
+      const existingHandler = requestHandlers.get(this);
+      if (existingHandler)
+        this.removeEventListener('readystatechange', existingHandler);
+
+      const startContext: RequestStartContext = {
+        type: 'xmlhttprequest',
+        method: requestData.method,
+        url: requestData.url,
+      };
+
+      const span = createNetworkSpan(startContext, 'xmlhttprequest');
+      trackedSpans.set(this, span);
+      const { onRequestEnd } = requestTracker.start(startContext);
+
+      const onReadyStateChange: ReadyStateChangeHandler = () => {
+        if (this.readyState === xhr.DONE && onRequestEnd) {
+          const activeSpan = trackedSpans.get(this);
+
+          // Determine request outcome based on status code
+          let endContext: RequestEndContext;
+
+          if (this.status <= 0 || this.status >= 400) {
+            endContext = { state: 'error', status: this.status };
+          } else {
+            endContext = { state: 'success', status: this.status };
+          }
+
+          if (activeSpan) {
+            completeNetworkSpan(
+              activeSpan,
+              startContext,
+              endContext,
+              endContext.state === 'error'
+            );
+            trackedSpans.delete(this);
+          }
+
+          onRequestEnd(endContext);
+        }
+      };
+
+      this.addEventListener('readystatechange', onReadyStateChange);
+      requestHandlers.set(this, onReadyStateChange);
+    }
+
+    originalSend.call(this, body);
+  };
+
+  return requestTracker;
+}
+
+export default createXmlHttpRequestTracker;

package/src/network-interceptor/request-tracker.ts

@@ -0,0 +1,31 @@
+import type {
+  RequestStartContext,
+  RequestEndContext,
+  RequestStartCallback,
+} from './network.interface';
+
+export class RequestTracker {
+  private callbacks: RequestStartCallback[] = [];
+
+  onStart(startCallback: RequestStartCallback) {
+    this.callbacks.push(startCallback);
+  }
+
+  start(context: RequestStartContext) {
+    const results: Array<ReturnType<RequestStartCallback>> = [];
+    for (const startCallback of this.callbacks) {
+      const result = startCallback(context);
+      if (result) results.push(result);
+    }
+
+    return {
+      onRequestEnd: (endContext: RequestEndContext) => {
+        for (const result of results) {
+          if (result && result.onRequestEnd) {
+            result.onRequestEnd(endContext);
+          }
+        }
+      },
+    };
+  }
+}

package/src/network-interceptor/span-helpers.ts

@@ -0,0 +1,84 @@
+import { Platform } from 'react-native';
+import type {
+  RequestStartContext,
+  RequestEndContext,
+} from './network.interface';
+import type { Span } from '../index';
+import { Pulse, SpanStatusCode } from '../index';
+import type { PulseAttributes } from '../pulse.interface';
+import { extractHttpAttributes } from './url-helper';
+
+export function setNetworkSpanAttributes(
+  span: Span,
+  startContext: RequestStartContext,
+  endContext: RequestEndContext
+): PulseAttributes {
+  const method = startContext.method.toUpperCase();
+  let attributes: PulseAttributes = {
+    'http.method': method,
+    'http.url': startContext.url,
+    'pulse.type': `network.${endContext.status ?? 0}`,
+    'http.request.type': startContext.type,
+    'platform': Platform.OS as 'android' | 'ios' | 'web',
+  };
+
+  // We had implemented our own URL parsing helper to avoid errors on RN < 0.80. Since this is not supported by React Native. 
+  // Check here: https://github.com/facebook/react-native/blob/v0.79.0/packages/react-native/Libraries/Blob/URL.js
+  const urlAttributes = extractHttpAttributes(startContext.url);
+  attributes = { ...attributes, ...urlAttributes };
+
+  if (endContext.status) {
+    attributes['http.status_code'] = endContext.status;
+  }
+
+  if (endContext.state === 'error' && endContext.error) {
+    attributes.error = true;
+    attributes['error.message'] =
+      endContext.error.message || String(endContext.error);
+    if (endContext.error.stack) {
+      attributes['error.stack'] = endContext.error.stack;
+    }
+    span.recordException(endContext.error, attributes);
+  }
+
+  span.setAttributes(attributes);
+  return attributes;
+}
+
+export function createNetworkSpan(
+  startContext: RequestStartContext,
+  interceptorType: 'fetch' | 'xmlhttprequest'
+): Span {
+  const method = startContext.method.toUpperCase();
+  const spanName = `HTTP ${method}`;
+
+  const span = Pulse.startSpan(spanName, {
+    attributes: {
+      'http.method': method,
+      'http.url': startContext.url,
+      'pulse.type': 'network',
+      'http.request.type': interceptorType,
+    },
+  });
+
+  return span;
+}
+
+export function completeNetworkSpan(
+  span: Span,
+  startContext: RequestStartContext,
+  endContext: RequestEndContext,
+  isError: boolean
+): void {
+  try {
+    const attributes = setNetworkSpanAttributes(span, startContext, endContext);
+    console.log('[Pulse] Network span completed', {
+      spanId: span.spanId,
+      spanAttributes: attributes,
+    });
+  } catch (e) {
+    console.error('[Pulse] Failed to set span attributes:', e);
+  }
+
+  span.end(isError ? SpanStatusCode.ERROR : SpanStatusCode.UNSET);
+}