@dreamhorizonorg/pulse-react-native 0.0.1

package/src/network-interceptor/url-helper.ts

@@ -0,0 +1,155 @@
+/**
+ * URL parsing helper for React Native
+ * Provides consistent URL parsing across all RN versions
+ *
+ * React Native < 0.80 throws errors for URL properties like hostname, protocol, etc.
+ * This helper uses the same regex approach as RN 0.80+ to ensure compatibility.
+ *
+ * Based on: https://github.com/facebook/react-native/blob/v0.80.0/packages/react-native/Libraries/Blob/URL.js
+ */
+
+export interface ParsedUrl {
+  protocol: string;
+  hostname: string;
+  host: string;
+  port: string;
+  pathname: string;
+  search: string;
+  hash: string;
+  href: string;
+}
+
+/**
+ * Safely extract a regex match group
+ * Returns empty string if match fails or group is undefined
+ */
+function safeMatch(
+  text: string,
+  regex: RegExp,
+  groupIndex: number = 1
+): string {
+  try {
+    const match = text.match(regex);
+    return match && match[groupIndex] ? match[groupIndex] : '';
+  } catch (e) {
+    return '';
+  }
+}
+
+/**
+ * Parse a URL string into its components
+ * Returns null if URL is invalid or cannot be parsed
+ *
+ * This function is defensive and will return empty strings for any component
+ * that cannot be extracted, rather than throwing errors.
+ */
+export function parseUrl(url: string): ParsedUrl | null {
+  // Validate input
+  if (!url || typeof url !== 'string' || url.trim().length === 0) {
+    return null;
+  }
+
+  // Ensure URL has a protocol (required for proper parsing)
+  if (!url.match(/^[a-zA-Z][a-zA-Z\d+\-.]*:/)) {
+    // Not a valid absolute URL
+    return null;
+  }
+
+  try {
+    // Protocol - e.g., "https:"
+    const protocol = safeMatch(url, /^([a-zA-Z][a-zA-Z\d+\-.]*):/);
+    const protocolWithColon = protocol ? `${protocol}:` : '';
+
+    // Hostname - e.g., "example.com"
+    const hostname = safeMatch(url, /^https?:\/\/(?:[^@]+@)?([^:/?#]+)/);
+
+    // Port - e.g., "8080"
+    const port = safeMatch(url, /:(\d+)(?=[/?#]|$)/);
+
+    // Host (hostname + port if present) - e.g., "example.com:8080"
+    const host = hostname ? (port ? `${hostname}:${port}` : hostname) : '';
+
+    // Pathname - e.g., "/api/users"
+    const pathMatch = url.match(/https?:\/\/[^/]+(\/[^?#]*)?/);
+    const pathname = pathMatch && pathMatch[1] ? pathMatch[1] : '/';
+
+    // Search - e.g., "?id=123"
+    const searchContent = safeMatch(url, /\?([^#]*)/);
+    const search = searchContent ? `?${searchContent}` : '';
+
+    // Hash - e.g., "#section"
+    const hashContent = safeMatch(url, /#([^/]*)/);
+    const hash = hashContent ? `#${hashContent}` : '';
+
+    return {
+      protocol: protocolWithColon,
+      hostname: hostname,
+      host: host,
+      port: port,
+      pathname: pathname,
+      search: search,
+      hash: hash,
+      href: url,
+    };
+  } catch (e) {
+    // Any unexpected error during parsing - return null
+    console.warn('[Pulse] URL parsing failed:', e);
+    return null;
+  }
+}
+
+/**
+ * Extract HTTP attributes from a URL string for OpenTelemetry span attributes
+ */
+export function extractHttpAttributes(url: string): {
+  'http.scheme'?: string;
+  'http.host'?: string;
+  'http.target'?: string;
+  'net.peer.name'?: string;
+  'net.peer.port'?: number;
+} {
+  try {
+    const parsed = parseUrl(url);
+    if (!parsed) {
+      return {};
+    }
+
+    const attributes: {
+      'http.scheme'?: string;
+      'http.host'?: string;
+      'http.target'?: string;
+      'net.peer.name'?: string;
+      'net.peer.port'?: number;
+    } = {};
+
+    // http.scheme - protocol without colon (e.g., "https")
+    if (parsed.protocol && parsed.protocol.length > 0) {
+      attributes['http.scheme'] = parsed.protocol.replace(':', '');
+    }
+
+    // http.host and net.peer.name - hostname (e.g., "api.example.com")
+    if (parsed.hostname && parsed.hostname.length > 0) {
+      attributes['http.host'] = parsed.hostname;
+      attributes['net.peer.name'] = parsed.hostname;
+    }
+
+    // http.target - pathname + search (e.g., "/api/users?id=123")
+    if (parsed.pathname && parsed.pathname.length > 0) {
+      attributes['http.target'] = parsed.pathname + parsed.search;
+    }
+
+    // net.peer.port - port number (e.g., 8080)
+    if (parsed.port && parsed.port.length > 0) {
+      const portNum = parseInt(parsed.port, 10);
+      if (!isNaN(portNum) && portNum > 0 && portNum <= 65535) {
+        attributes['net.peer.port'] = portNum;
+      }
+    }
+
+    return attributes;
+  } catch (e) {
+    // Absolutely ensure this function never throws
+    console.warn('[Pulse] Failed to extract HTTP attributes from URL:', e);
+    return {};
+  }
+}

package/src/pulse.interface.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenTelemetry attribute value types.
+ * Based on OpenTelemetry JavaScript SDK attribute types.
+ * @see https://github.com/open-telemetry/opentelemetry-js/blob/main/api/src/common/Attributes.ts
+ */
+export type PulseAttributeValue =
+  | string
+  | number
+  | boolean
+  | string[]
+  | number[]
+  | boolean[];
+
+export type PulseAttributes = Record<string, PulseAttributeValue | undefined>;

package/src/reactNavigation.tsx

@@ -0,0 +1,146 @@
+import { Pulse, type Span } from './index';
+
+const NAVIGATION_HISTORY_MAX_SIZE = 200;
+
+export interface NavigationRoute {
+  name: string;
+  key: string;
+  params?: Record<string, any>;
+}
+
+interface NavigationContainer {
+  addListener: (type: string, listener: (event?: unknown) => void) => void;
+  getCurrentRoute: () => NavigationRoute | undefined;
+}
+
+export function createReactNavigationIntegration() {
+  let navigationContainer: NavigationContainer | undefined;
+  let latestRoute: NavigationRoute | undefined;
+  let recentRouteKeys: string[] = [];
+  let isInitialized = false;
+  let span: Span | undefined;
+
+  const onNavigationDispatch = (): void => {
+    try {
+      span = Pulse.startSpan('Navigated', {
+        attributes: {
+          'pulse.type': 'screen_load',
+          'phase': 'start',
+        },
+      });
+
+      console.log('[Pulse Navigation] Navigation dispatch span started', span);
+    } catch (error) {
+      console.warn('[Pulse Navigation] Error in onNavigationDispatch:', error);
+    }
+  };
+
+  const onStateChange = (): void => {
+    try {
+      if (!navigationContainer) {
+        console.warn('[Pulse Navigation] Navigation container not registered');
+        return;
+      }
+
+      const currentRoute = navigationContainer.getCurrentRoute();
+      if (!currentRoute) {
+        return;
+      }
+
+      if (!span) {
+        latestRoute = currentRoute;
+        pushRecentRouteKey(currentRoute.key);
+        return;
+      }
+
+      const previousRoute = latestRoute;
+
+      if (previousRoute && previousRoute.key === currentRoute.key) {
+        return;
+      }
+
+      latestRoute = currentRoute;
+
+      const routeHasBeenSeen = recentRouteKeys.includes(currentRoute.key);
+      pushRecentRouteKey(currentRoute.key);
+
+      span?.setAttributes({
+        'screen.name': currentRoute.name,
+        'last.screen.name': previousRoute?.name || undefined,
+        'routeHasBeenSeen': routeHasBeenSeen,
+        'routeKey': currentRoute.key,
+      });
+
+      span?.end();
+      console.log('[Pulse Navigation] Navigation dispatch span ended', span);
+      span = undefined;
+    } catch (error) {
+      console.warn('[Pulse Navigation] Error in onStateChange:', error);
+      span = undefined;
+    }
+  };
+
+  const registerNavigationContainer = (
+    maybeNavigationContainer: unknown
+  ): void => {
+    try {
+      let container: NavigationContainer | undefined;
+      if (
+        typeof maybeNavigationContainer === 'object' &&
+        maybeNavigationContainer !== null &&
+        'current' in maybeNavigationContainer
+      ) {
+        container = maybeNavigationContainer.current as NavigationContainer;
+      } else {
+        container = maybeNavigationContainer as NavigationContainer;
+      }
+
+      if (!container) {
+        console.warn('[Pulse Navigation] Invalid navigation container ref');
+        return;
+      }
+
+      if (isInitialized && navigationContainer === container) {
+        console.log('[Pulse Navigation] Container already registered');
+        return;
+      }
+
+      navigationContainer = container;
+
+      navigationContainer.addListener(
+        '__unsafe_action__',
+        onNavigationDispatch
+      );
+      navigationContainer.addListener('state', onStateChange);
+
+      const currentRoute = navigationContainer.getCurrentRoute();
+      if (currentRoute) {
+        latestRoute = currentRoute;
+        pushRecentRouteKey(currentRoute.key);
+      }
+
+      isInitialized = true;
+      console.log('[Pulse Navigation] Integration initialized successfully');
+    } catch (error) {
+      console.error('[Pulse Navigation] Error registering container:', error);
+    }
+  };
+
+  const pushRecentRouteKey = (key: string): void => {
+    recentRouteKeys.push(key);
+
+    if (recentRouteKeys.length > NAVIGATION_HISTORY_MAX_SIZE) {
+      recentRouteKeys = recentRouteKeys.slice(
+        recentRouteKeys.length - NAVIGATION_HISTORY_MAX_SIZE
+      );
+    }
+  };
+
+  return {
+    registerNavigationContainer,
+  };
+}
+
+export type ReactNavigationIntegration = ReturnType<
+  typeof createReactNavigationIntegration
+>;

package/src/trace.ts

@@ -0,0 +1,108 @@
+import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { isSupportedPlatform } from './initialization';
+import { mergeWithGlobalAttributes } from './globalAttributes';
+import { extractErrorDetails } from './utility';
+import type { PulseAttributes } from './pulse.interface';
+
+export type SpanOptions = {
+  attributes?: PulseAttributes;
+};
+
+export enum SpanStatusCode {
+  OK = 'OK',
+  ERROR = 'ERROR',
+  UNSET = 'UNSET',
+}
+
+export type Span = {
+  end: (statusCode?: SpanStatusCode) => void;
+  addEvent: (name: string, attributes?: PulseAttributes) => void;
+  setAttributes: (attributes?: PulseAttributes) => void;
+  recordException: (error: Error, attributes?: PulseAttributes) => void;
+  // This is the auto-generated ID for span on the native side.
+  spanId?: string;
+};
+
+export function startSpan(name: string, options?: SpanOptions): Span {
+  if (!isSupportedPlatform()) {
+    return {
+      end: (_statusCode?: SpanStatusCode) => {},
+      addEvent: (_eventName: string, _eventAttributes?: PulseAttributes) => {},
+      setAttributes: (_attributes?: PulseAttributes) => {},
+      recordException: (_error: Error, _attributes?: PulseAttributes) => {},
+      spanId: undefined,
+    };
+  }
+
+  const mergedAttributes = mergeWithGlobalAttributes(options?.attributes || {});
+  const spanId = PulseReactNativeOtel.startSpan(name, mergedAttributes);
+  return {
+    end: (statusCode?: SpanStatusCode) => {
+      return endSpan(spanId, statusCode);
+    },
+    addEvent: (eventName: string, eventAttributes?: PulseAttributes) => {
+      return addSpanEvent(spanId, eventName, eventAttributes);
+    },
+    setAttributes: (spanAttributes?: PulseAttributes) => {
+      return setSpanAttributes(spanId, spanAttributes);
+    },
+    recordException: (error: Error, attributes?: PulseAttributes) => {
+      return recordSpanException(error, attributes);
+    },
+    spanId: spanId,
+  };
+}
+
+export function trackSpan<T>(
+  name: string,
+  options: SpanOptions,
+  fn: () => T | Promise<T>
+): T | Promise<T> {
+  if (!isSupportedPlatform()) {
+    return fn();
+  }
+
+  const mergedAttributes = mergeWithGlobalAttributes(options?.attributes || {});
+  const spanId = PulseReactNativeOtel.startSpan(name, mergedAttributes);
+
+  const result = fn();
+
+  if (result && typeof (result as any).then === 'function') {
+    return (result as Promise<T>).finally(() => {
+      endSpan(spanId, SpanStatusCode.UNSET);
+    });
+  }
+
+  endSpan(spanId, SpanStatusCode.UNSET);
+  return result as T;
+}
+
+function endSpan(spanId: string, statusCode?: SpanStatusCode): void {
+  PulseReactNativeOtel.endSpan(spanId, statusCode);
+}
+
+function addSpanEvent(
+  spanId: string,
+  name: string,
+  attributes?: PulseAttributes
+): void {
+  PulseReactNativeOtel.addSpanEvent(spanId, name, attributes || undefined);
+}
+
+function setSpanAttributes(spanId: string, attributes?: PulseAttributes): void {
+  PulseReactNativeOtel.setSpanAttributes(spanId, attributes || undefined);
+}
+
+function recordSpanException(error: Error, attributes?: PulseAttributes): void {
+  const { message, stackTrace, errorType } = extractErrorDetails(error);
+  const observedTimeMs = Date.now();
+  const mergedAttributes = mergeWithGlobalAttributes(attributes || {});
+  PulseReactNativeOtel.reportException(
+    message,
+    observedTimeMs,
+    stackTrace || '',
+    false,
+    errorType,
+    mergedAttributes
+  );
+}

package/src/user.ts

@@ -0,0 +1,24 @@
+import PulseReactNativeOtel from './NativePulseReactNativeOtel';
+import { isSupportedPlatform } from './initialization';
+import type { PulseAttributes } from './pulse.interface';
+
+export function setUserId(id: string | null): void {
+  if (!isSupportedPlatform()) {
+    return;
+  }
+  PulseReactNativeOtel.setUserId(id);
+}
+
+export function setUserProperty(name: string, value: string | null): void {
+  if (!isSupportedPlatform()) {
+    return;
+  }
+  PulseReactNativeOtel.setUserProperty(name, value);
+}
+
+export function setUserProperties(properties: PulseAttributes): void {
+  if (!isSupportedPlatform()) {
+    return;
+  }
+  PulseReactNativeOtel.setUserProperties(properties);
+}

package/src/utility.ts

@@ -0,0 +1,36 @@
+export function nowMs(): number {
+  const perf = global.performance;
+  if (perf && typeof perf.now === 'function') return perf.now();
+  return Date.now();
+}
+
+export function getAbsoluteUrl(url: string, baseUrl?: string): string {
+  // if it looks like an absolute url do nothing
+  if (url.indexOf('https://') === 0 || url.indexOf('http://') === 0) return url;
+
+  try {
+    const absoluteUrl = new URL(url, baseUrl).href;
+
+    // if a trailing slash has been added inadvertently remove it
+    if (!url.endsWith('/') && absoluteUrl.endsWith('/')) {
+      return absoluteUrl.slice(0, -1);
+    }
+
+    return absoluteUrl;
+  } catch {
+    // not a valid URL for some reason - simply return it
+    return url;
+  }
+}
+
+export function extractErrorDetails(error: Error): {
+  message: string;
+  stackTrace: string;
+  errorType: string;
+} {
+  const message = error.message || 'Unknown error';
+  const stackTrace = error.stack || '';
+  const errorType = error.name || '';
+
+  return { message, stackTrace, errorType };
+}