@coralogix/react-native-plugin 0.1.0

package/index.cjs.js

@@ -0,0 +1,682 @@
+'use strict';
+
+var reactNative = require('react-native');
+var instrumentationFetch = require('@opentelemetry/instrumentation-fetch');
+var instrumentation = require('@opentelemetry/instrumentation');
+var sdkTraceWeb = require('@opentelemetry/sdk-trace-web');
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+let CoralogixLogSeverity = /*#__PURE__*/function (CoralogixLogSeverity) {
+  CoralogixLogSeverity[CoralogixLogSeverity["Debug"] = 1] = "Debug";
+  CoralogixLogSeverity[CoralogixLogSeverity["Verbose"] = 2] = "Verbose";
+  CoralogixLogSeverity[CoralogixLogSeverity["Info"] = 3] = "Info";
+  CoralogixLogSeverity[CoralogixLogSeverity["Warn"] = 4] = "Warn";
+  CoralogixLogSeverity[CoralogixLogSeverity["Error"] = 5] = "Error";
+  CoralogixLogSeverity[CoralogixLogSeverity["Critical"] = 6] = "Critical";
+  return CoralogixLogSeverity;
+}({});
+
+let ErrorSource = /*#__PURE__*/function (ErrorSource) {
+  ErrorSource["CONSOLE"] = "console";
+  ErrorSource["GLOBAL"] = "global";
+  return ErrorSource;
+}({});
+
+const ERROR_INSTRUMENTATION_NAME = 'errors';
+const ERROR_INSTRUMENTATION_VERSION = '1';
+
+let defaultConsoleError = (..._params) => {};
+const MESSAGE_LIMIT = 1024;
+const getCircularReplacer = () => {
+  const seen = new WeakSet();
+  return (_key, value) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+};
+class CoralogixErrorInstrumentation extends instrumentation.InstrumentationBase {
+  constructor(config) {
+    super(ERROR_INSTRUMENTATION_NAME, ERROR_INSTRUMENTATION_VERSION, config);
+    this.parseErrorObject = obj => {
+      var _obj$message;
+      return (_obj$message = obj == null ? void 0 : obj.message) != null ? _obj$message : JSON.stringify(obj, getCircularReplacer());
+    };
+  }
+  init() {}
+  listenToConsoleError() {
+    const onConsoleError = (...params) => {
+      defaultConsoleError.apply(console, params);
+      this.report(ErrorSource.CONSOLE, params);
+    };
+    defaultConsoleError = console.error;
+    console.error = onConsoleError;
+  }
+  report(source, arg) {
+    if (Array.isArray(arg)) {
+      if (arg.length === 0) {
+        return;
+      }
+    }
+    if (arg instanceof Error) {
+      this.reportError(arg);
+    } else if (typeof arg === 'string') {
+      this.reportString(arg);
+    } else if (Array.isArray(arg)) {
+      // if any arguments are Errors then add the stack trace even though the message is handled differently
+      const firstError = arg.find(x => x instanceof Error);
+      const message = arg.map(msg => typeof msg === 'string' ? msg : this.parseErrorObject(msg)).join(' ');
+      this.reportString(message, firstError);
+    } else {
+      this.reportString(typeof arg === 'string' ? arg : this.getPossibleEventMessage(arg));
+    }
+  }
+  reportError(err) {
+    CoralogixRum.reportError(err, false);
+  }
+  reportString(message, firstError) {
+    const truncatedMessage = (message == null ? void 0 : message.substring(0, MESSAGE_LIMIT)) || '';
+    CoralogixRum.reportError({
+      name: (firstError == null ? void 0 : firstError.name) || 'CONSOLE',
+      message: truncatedMessage,
+      stack: firstError == null ? void 0 : firstError.stack
+    }, false);
+  }
+  getPossibleEventMessage(event) {
+    const {
+      message,
+      statusMessage
+    } = event || {};
+    if (message && typeof message === 'string') {
+      return message;
+    }
+
+    // GrpcStatusEvent
+    if (statusMessage && typeof statusMessage === 'string') {
+      return statusMessage;
+    }
+    return JSON.stringify(event);
+  }
+  enable() {
+    const defaultHandler = ErrorUtils.getGlobalHandler();
+    ErrorUtils.setGlobalHandler((error, isFatal) => {
+      this.report(ErrorSource.GLOBAL, error);
+      if (defaultHandler) {
+        setTimeout(() => {
+          defaultHandler(error, isFatal);
+        }, 2500);
+      }
+    });
+    this.listenToConsoleError();
+  }
+  disable() {}
+}
+
+const DEFAULT_SAMPLE_DURATION_MS = 5000;
+const DEFAULT_SAMPLE_INTERVAL_MS = 60000;
+let isSampling = false;
+let rafId = null;
+let intervalTimer = null;
+let appState = 'active';
+let appStateSub = null;
+function startJsRefreshRateSampler({
+  sampleDurationMs = DEFAULT_SAMPLE_DURATION_MS,
+  sampleIntervalMs = DEFAULT_SAMPLE_INTERVAL_MS,
+  onSample
+}) {
+  var _AppState$currentStat;
+  if (isSampling) return;
+  isSampling = true;
+  let firstTimestamp = null;
+  let lastTimestamp = null;
+  let frameCount = 0;
+  const requestNext = () => {
+    rafId = requestAnimationFrame(loop);
+  };
+  const loop = t => {
+    if (appState === 'active') {
+      if (firstTimestamp === null) firstTimestamp = t;
+      lastTimestamp = t;
+      frameCount += 1;
+    }
+    requestNext();
+  };
+  const stopRaf = () => {
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+  };
+  const resetCounters = () => {
+    firstTimestamp = null;
+    lastTimestamp = null;
+    frameCount = 0;
+  };
+  const getElapsedMs = () => {
+    if (firstTimestamp == null || lastTimestamp == null) return 0;
+    return Math.max(0, lastTimestamp - firstTimestamp);
+  };
+  const computeAverageRafRate = () => {
+    const elapsedMs = getElapsedMs();
+    if (elapsedMs === 0) return 0;
+    return (frameCount - 1) * 1000 / elapsedMs;
+  };
+  const runSample = () => {
+    if (!isSampling) return;
+    if (appState !== 'active') {
+      scheduleNextSample();
+      return;
+    }
+    resetCounters();
+    requestNext();
+    setTimeout(() => {
+      stopRaf();
+      const rafRate = computeAverageRafRate();
+      onSample(rafRate);
+      scheduleNextSample();
+    }, sampleDurationMs);
+  };
+  const scheduleNextSample = () => {
+    if (!isSampling) return;
+    intervalTimer = setTimeout(runSample, sampleIntervalMs);
+  };
+  const handleAppStateChange = next => {
+    appState = next;
+    if (next !== 'active') {
+      stopRaf();
+      resetCounters();
+    }
+  };
+  appState = (_AppState$currentStat = reactNative.AppState.currentState) != null ? _AppState$currentStat : 'active';
+  appStateSub = reactNative.AppState.addEventListener('change', handleAppStateChange);
+  runSample();
+}
+function stopJsRefreshRateSampler() {
+  var _appStateSub;
+  isSampling = false;
+  if (intervalTimer) {
+    clearTimeout(intervalTimer);
+    intervalTimer = null;
+  }
+  if (rafId !== null) {
+    cancelAnimationFrame(rafId);
+    rafId = null;
+  }
+  (_appStateSub = appStateSub) == null || _appStateSub.remove();
+  appStateSub = null;
+}
+
+var version = "0.1.0";
+var pkg = {
+	version: version};
+
+class Logger {
+  constructor(config = {}) {
+    var _config$shouldLog, _config$prefix;
+    this._shouldLog = void 0;
+    this._prefix = void 0;
+    this._shouldLog = (_config$shouldLog = config.shouldLog) != null ? _config$shouldLog : false;
+    this._prefix = (_config$prefix = config.prefix) != null ? _config$prefix : '[Coralogix React Native SDK] - ';
+  }
+  set shouldLog(value) {
+    this._shouldLog = value;
+  }
+  debug(message, ...args) {
+    if (this._shouldLog) {
+      console.debug(`${this._prefix} ${message}`, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this._shouldLog) {
+      console.info(`${this._prefix} ${message}`, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this._shouldLog) {
+      console.warn(`${this._prefix} ${message}`, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this._shouldLog) {
+      console.error(`${this._prefix} ${message}`, ...args);
+    }
+  }
+}
+const logger = new Logger();
+
+const propagateTraceHeaderCorsUrls = config => {
+  var _traceParentInHeader$;
+  const {
+    traceParentInHeader
+  } = config;
+  const propagateCorsUrls = traceParentInHeader == null || (_traceParentInHeader$ = traceParentInHeader.options) == null ? void 0 : _traceParentInHeader$.propagateTraceHeaderCorsUrls;
+  if (traceParentInHeader != null && traceParentInHeader.enabled && propagateCorsUrls) {
+    config.propagateTraceHeaderCorsUrls = propagateCorsUrls;
+  }
+};
+
+const CORALOGIX_LOGS_URL_SUFFIX = '/browser/v1beta/logs';
+const CORALOGIX_RECORDING_URL_SUFFIX = '/sessionrecording';
+const OPTIONS_DEFAULTS = {
+  ignoreUrls: [new RegExp(CORALOGIX_LOGS_URL_SUFFIX), new RegExp(CORALOGIX_RECORDING_URL_SUFFIX)],
+  user_context: {
+    user_id: '',
+    user_name: ''
+  },
+  labels: {},
+  view_context: {
+    view: ''
+  }
+};
+
+const hrTimeToMilliseconds = ([seconds, nanoseconds]) => seconds * 1000 + Math.round(nanoseconds / 1e6);
+const getUrlFragments = url => {
+  if (!url) {
+    return '';
+  }
+  try {
+    if (url.startsWith('blob:')) {
+      return url;
+    }
+    return new URL(url).pathname.substring(1) || '/';
+  } catch (err) {
+    logger.warn('Error parsing URL', err);
+    return url;
+  }
+};
+function isSamplingOn(threshold) {
+  return threshold > 0 && Math.random() * 100 <= threshold;
+}
+function resolveCoralogixOtelWebConfig(config) {
+  var _config$sessionSample, _config$view_context;
+  const {
+    ignoreUrls,
+    debug
+  } = config;
+  const resolvedIgnoreUrls = [];
+  ignoreUrls && resolvedIgnoreUrls.push(...ignoreUrls);
+  OPTIONS_DEFAULTS.ignoreUrls && resolvedIgnoreUrls.push(...OPTIONS_DEFAULTS.ignoreUrls);
+  return _extends({}, OPTIONS_DEFAULTS, config, {
+    ignoreUrls: resolvedIgnoreUrls,
+    sessionSampleRate: (_config$sessionSample = config.sessionSampleRate) != null ? _config$sessionSample : 100,
+    debug,
+    view_context: (_config$view_context = config.view_context) != null ? _config$view_context : OPTIONS_DEFAULTS.view_context
+  });
+}
+
+let OtelNetworkAttrs = /*#__PURE__*/function (OtelNetworkAttrs) {
+  OtelNetworkAttrs["METHOD"] = "http.method";
+  OtelNetworkAttrs["URL"] = "http.url";
+  OtelNetworkAttrs["STATUS_CODE"] = "http.status_code";
+  OtelNetworkAttrs["HOST"] = "http.host";
+  OtelNetworkAttrs["SCHEME"] = "http.scheme";
+  OtelNetworkAttrs["STATUS_TEXT"] = "http.status_text";
+  OtelNetworkAttrs["RESPONSE_CONTENT_LENGTH"] = "http.response_content_length";
+  OtelNetworkAttrs["OtelNetworkAttrs"] = "OtelNetworkAttrs";
+  return OtelNetworkAttrs;
+}({});
+
+class CoralogixFetchInstrumentation extends instrumentationFetch.FetchInstrumentation {
+  constructor(config) {
+    propagateTraceHeaderCorsUrls(config);
+    config.applyCustomAttributesOnSpan = (span, request, result) => {
+      span.end();
+      const readableSpan = span;
+      const attrs = readableSpan.attributes;
+      const method = attrs[OtelNetworkAttrs.METHOD];
+      const url = attrs[OtelNetworkAttrs.URL];
+      const statusCode = result.status;
+      const statusText = attrs[OtelNetworkAttrs.STATUS_TEXT];
+      const responseContentLength = attrs[OtelNetworkAttrs.RESPONSE_CONTENT_LENGTH] || 0;
+      const duration = hrTimeToMilliseconds(readableSpan.duration);
+      const fragments = getUrlFragments(url);
+      const errorMessage = result.message;
+      const customTraceId = readableSpan.spanContext().traceId;
+      const customSpanId = readableSpan.spanContext().spanId;
+      const parsed = new URL(url);
+      const host = parsed.host; // e.g. "example.com:443"
+      const schema = parsed.protocol.replace(":", ""); // e.g. "https"
+
+      const details = {
+        method,
+        statusCode,
+        url,
+        fragments,
+        host,
+        schema,
+        statusText,
+        duration,
+        responseContentLength,
+        errorMessage,
+        customTraceId,
+        customSpanId
+      };
+      CoralogixRum.reportNetworkRequest(details);
+    };
+    super(config);
+  }
+  enable() {
+    super.enable();
+  }
+}
+
+let CoralogixDomain = /*#__PURE__*/function (CoralogixDomain) {
+  CoralogixDomain["EU1"] = "EU1";
+  CoralogixDomain["EU2"] = "EU2";
+  CoralogixDomain["US1"] = "US1";
+  CoralogixDomain["US2"] = "US2";
+  CoralogixDomain["AP1"] = "AP1";
+  CoralogixDomain["AP2"] = "AP2";
+  CoralogixDomain["AP3"] = "AP3";
+  CoralogixDomain["STAGING"] = "staging";
+  return CoralogixDomain;
+}({});
+
+const LINKING_ERROR = `The package 'cx-plugin' doesn't seem to be linked. Make sure: \n\n` + reactNative.Platform.select({
+  ios: "- You have run 'pod install'\n",
+  default: ''
+}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
+let beforeSendCallback;
+let _deregisterInstrumentations;
+const CxSdk = reactNative.NativeModules.CxSdk ? reactNative.NativeModules.CxSdk : createErrorProxy(LINKING_ERROR);
+function createErrorProxy(errorMessage) {
+  return new Proxy({}, {
+    get() {
+      throw new Error(errorMessage);
+    }
+  });
+}
+let isInited = false;
+let fetchInstrumentation;
+const CoralogixRum = {
+  get isInited() {
+    return isInited;
+  },
+  init: function (options) {
+    var _resolvedOptions$debu;
+    if (isInited) {
+      console.warn('[Coralogix React Native SDK] - already initialized');
+      return;
+    }
+    const resolvedOptions = resolveCoralogixOtelWebConfig(options);
+    logger.shouldLog = (_resolvedOptions$debu = resolvedOptions.debug) != null ? _resolvedOptions$debu : false;
+    if (!isSamplingOn(resolvedOptions.sessionSampleRate)) {
+      logger.debug('CoralogixRum: Session tracking is disabled');
+      return;
+    }
+    registerCoralogixInstrumentations(resolvedOptions);
+    CxSdk.initialize(_extends({}, resolvedOptions, {
+      frameworkVersion: pkg.version
+    }));
+    isInited = true;
+  },
+  shutdown: () => {
+    if (!isInited) {
+      return;
+    }
+    CxSdk.shutdown();
+    if (subscription) {
+      subscription.remove();
+    }
+    isInited = false;
+    _deregisterInstrumentations == null || _deregisterInstrumentations();
+    _deregisterInstrumentations = undefined;
+    cleanupResources();
+  },
+  setApplicationContext: applicationContext => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before setting application context');
+      return;
+    }
+    CxSdk.setApplicationContext(applicationContext);
+  },
+  setUserContext: userContext => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before setting user context');
+      return;
+    }
+    CxSdk.setUserContext(userContext);
+  },
+  setViewContext(viewContext) {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before setting view context');
+      return;
+    }
+    CxSdk.setViewContext(viewContext.view);
+  },
+  getUserContext: async () => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before getting user context');
+      return undefined;
+    }
+    const result = await CxSdk.getUserContext();
+    if (!result || typeof result !== 'object') {
+      return undefined;
+    }
+    return {
+      user_id: result.user_id || '',
+      user_name: result.user_name || '',
+      user_email: result.user_email || '',
+      user_metadata: result.user_metadata || {}
+    };
+  },
+  setLabels: labels => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before setting labels');
+      return;
+    }
+    CxSdk.setLabels(labels);
+  },
+  getLabels: async () => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before getting labels');
+      return {};
+    }
+    return await CxSdk.getLabels();
+  },
+  getSessionId: async () => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before getting session id');
+      return '';
+    }
+    return CxSdk.getSessionId();
+  },
+  log: (severity, message, data) => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before using log');
+      return;
+    }
+    CxSdk.log(severity, message, data != null ? data : {});
+  },
+  debug(message, data) {
+    this.log(CoralogixLogSeverity.Debug, message, data);
+  },
+  verbose(message, data) {
+    this.log(CoralogixLogSeverity.Verbose, message, data);
+  },
+  info(message, data) {
+    this.log(CoralogixLogSeverity.Info, message, data);
+  },
+  warn(message, data) {
+    this.log(CoralogixLogSeverity.Warn, message, data);
+  },
+  error(message, data) {
+    this.log(CoralogixLogSeverity.Error, message, data);
+  },
+  critical(message, data) {
+    this.log(CoralogixLogSeverity.Critical, message, data);
+  },
+  reportNetworkRequest: details => {
+    CxSdk.reportNetworkRequest(details);
+  },
+  sendCustomMeasurement: measurement => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before sending custom measurements');
+      return;
+    }
+    CxSdk.sendCustomMeasurement(measurement);
+  },
+  reportError: (error, isCrash) => {
+    if (!isInited) {
+      logger.debug('CoralogixRum must be initiated before error reporting');
+      return;
+    }
+    const errorDetails = {
+      error_type: error.name,
+      error_message: error.message,
+      stack_trace: parseErrorStack(error),
+      is_crash: isCrash
+    };
+    CxSdk.reportError(errorDetails);
+  }
+};
+function trackMobileVitals(options) {
+  startJsRefreshRateSampler(_extends({}, options.jsRefreshRateSampleRate, {
+    onSample: jsRefreshRate => {
+      CxSdk.reportMobileVitalsMeasurement('js_refresh_rate', Math.round(jsRefreshRate), 'fps');
+    }
+  }));
+
+  // startJSLoopDetector({
+  //   ...options.jsLoopDetection,
+  //   onFrameDrop: (event) => {
+  //     CxSdk.reportMobileVitalsMeasurementSet('js_loop', [
+  //       {
+  //         name: 'stall',
+  //         value: event.stall,
+  //         units: 'ms',
+  //       },
+  //       {
+  //         name: 'delta',
+  //         value: event.delta,
+  //         units: 'ms',
+  //       },
+  //     ]);
+  //   },
+  //   onError: (error) => {
+  //     logger.debug('[JSLoopDetector] Error:', { error });
+  //   },
+  // });
+}
+function cleanupResources() {
+  stopJsRefreshRateSampler();
+  // stopJSLoopDetector();
+}
+function registerCoralogixInstrumentations(options) {
+  if (options.beforeSend) {
+    beforeSendCallback = options.beforeSend;
+  }
+  const tracerProvider = new sdkTraceWeb.WebTracerProvider();
+  const instrumentations = [];
+  const instrumentationsOptions = options.instrumentations;
+
+  // disable network for ios, since swizzle will capture the fetch requests
+  const shouldInterceptNetowrk = reactNative.Platform.OS === 'android' && (!instrumentationsOptions || instrumentationsOptions.network !== false);
+  const shouldInterceptErrors = !instrumentationsOptions || instrumentationsOptions.errors !== false;
+  const shouldInterceptMobileVitals = !instrumentationsOptions || instrumentationsOptions.mobile_vitals !== false;
+
+  // Fetch instrumentation
+  if (shouldInterceptNetowrk) {
+    fetchInstrumentation = new CoralogixFetchInstrumentation(options);
+    instrumentations.push(fetchInstrumentation);
+  }
+
+  // Errors instrumentation
+  if (shouldInterceptErrors) {
+    const errorInstrumentation = new CoralogixErrorInstrumentation(options);
+    instrumentations.push(errorInstrumentation);
+  }
+
+  // Mobile vitals instrumentation
+  if (shouldInterceptMobileVitals) {
+    trackMobileVitals(options);
+  }
+
+  // Register Instrumentations
+  _deregisterInstrumentations = instrumentation.registerInstrumentations({
+    tracerProvider,
+    instrumentations
+  });
+}
+const parseErrorStack = error => {
+  if (!error.stack) {
+    return [];
+  }
+  const stackLines = error.stack.split('\n').slice(1); // Ignore the first line (error message)
+  return stackLines.map(line => {
+    const match = line.match(/\s*at\s+(.*)\s+\((.*):(\d+):(\d+)\)/) ||
+    // Matches function name, file, line, column
+    line.match(/\s*at\s+(.*):(\d+):(\d+)/); // Matches anonymous function calls
+
+    if (match) {
+      var _match$, _match$2;
+      return {
+        functionName: match[1] || '<anonymous>',
+        fileName: match[2],
+        lineNumber: parseInt((_match$ = match[3]) != null ? _match$ : '-1', 10),
+        columnNumber: parseInt((_match$2 = match[4]) != null ? _match$2 : '-1', 10)
+      };
+    }
+    return null;
+  }).filter(frame => frame !== null);
+};
+
+// Create event emitter
+const eventEmitter = new reactNative.NativeEventEmitter(CxSdk);
+
+// Subscribe to beforeSend events
+const subscription = eventEmitter.addListener('onBeforeSend', events => {
+  // logger.log("📨 onBeforeSend triggered with events: ", events)
+  // events is an array of events [[String: Any]]
+  // Skip processing if SDK is not initialized or events is empty
+  if (!CoralogixRum.isInited || !events || !Array.isArray(events)) {
+    logger.debug('⚠️ Skipping event processing - SDK not initialized or events invalid');
+    return;
+  }
+  logger.debug('🔄 Processing events with beforeSendCallback');
+  // Process event with beforeSendCallback if available
+  if (beforeSendCallback) {
+    try {
+      // Process each event in the array
+      const results = [];
+      for (const fullEvent of events) {
+        const event = fullEvent.text.cx_rum;
+        const res = beforeSendCallback(event);
+        if (!res) {
+          continue;
+        }
+        // Merge the result from each event
+        const mergeEvent = _extends({}, fullEvent, {
+          text: _extends({}, fullEvent.text, {
+            cx_rum: _extends({}, fullEvent.text.cx_rum, res)
+          })
+        });
+        results.push(mergeEvent);
+      }
+      if (results.length) {
+        CxSdk.sendCxSpanData(results);
+      }
+    } catch (error) {
+      logger.debug('❌ Error in beforeSend callback:', error);
+    }
+  } else {
+    logger.debug('⚠️ No beforeSendCallback available');
+  }
+});
+
+exports.CoralogixDomain = CoralogixDomain;
+exports.CoralogixLogSeverity = CoralogixLogSeverity;
+exports.CoralogixRum = CoralogixRum;

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";