@coralogix/react-native-plugin 0.1.0

package/ios/CxSdk.mm

@@ -0,0 +1,81 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(CxSdk, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSDictionary *)parameter
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(supportedEvents)
+
+RCT_EXTERN_METHOD(setUserContext:(NSDictionary *)userContext
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getUserContext:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setNetworkRequestContext:(NSDictionary *)networkRequestContext
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(isInited:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setLabels:(NSDictionary *)labels
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getLabels:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setViewContext:(NSString *)viewContext
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setApplicationContext:(NSDictionary *)applicationContext
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getSessionId:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(shutdown:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportError:(NSDictionary *)errorDictionary
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(log:(int)severity
+                  message:(NSString *)message
+                  data:(NSDictionary *)data
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportNetworkRequest:(NSDictionary *)networkRequestDictionary
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(sendCxSpanData:(NSArray *)beforeSendResults
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportMobileVitalsMeasurementSet:(NSString *)type
+                  metrics:(NSArray *)metrics
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reportMobileVitalsMeasurement:(NSString *)type
+                  value:(double)value
+                  units:(NSString *)units
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end

package/ios/CxSdk.swift

@@ -0,0 +1,371 @@
+import Foundation
+import Coralogix
+import React
+
+enum CxSdkError: Error {
+  case invalidPublicKey
+  case missingParameter
+}
+
+@objc(CxSdk)
+class CxSdk: RCTEventEmitter {
+  var coralogixRum: CoralogixRum?
+
+  override init() {
+    super.init()
+  }
+
+  override class func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
+  override func supportedEvents() -> [String]! {
+    return ["onBeforeSend"]
+  }
+
+  @objc(initialize:withResolver:withRejecter:)
+  func initialize(parameter: NSDictionary,
+                  resolve:RCTPromiseResolveBlock,
+                  reject:RCTPromiseRejectBlock) -> Void {
+    do {
+      // Create beforeSendCallback only if parameter["beforeSend"] is not null
+      let beforeSendCallBack: (([[String: Any]]) -> Void)? = parameter["beforeSend"] != nil ? { [weak self] (event: [[String: Any]]) -> Void in
+        // Convert the event dictionary to a format that
+        // can be safely passed to JavaScript
+        let jsEvent = event.map { (element) in
+          return self?.convertToJSCompatibleEvent(event: element)
+        }
+
+        self?.sendEvent(withName: "onBeforeSend", body: jsEvent)
+      } : nil
+
+      var options = try self.toCoralogixOptions(parameter: parameter)
+      options.beforeSendCallBack = beforeSendCallBack
+      let rnPluginVersion =  parameter["frameworkVersion"] as? String ?? ""
+
+      self.coralogixRum = CoralogixRum(options: options, sdkFramework: .reactNative(version: rnPluginVersion))
+      resolve("initialize success")
+    } catch let error as CxSdkError {
+      reject("CX_SDK_ERROR", error.localizedDescription, error)
+    } catch {
+      reject("UNEXPECTED_ERROR", "An unexpected error occurred: \(error.localizedDescription)", error)
+    }
+  }
+
+  @objc(setUserContext:withResolver:withRejecter:)
+  func setUserContext(userContextMap: NSDictionary,
+                      resolve:RCTPromiseResolveBlock,
+                      reject:RCTPromiseRejectBlock) -> Void {
+    let userContext = self.generateUserContext(parameter: userContextMap)
+    coralogixRum?.setUserContext(userContext: userContext)
+  }
+
+  @objc(getUserContext:withRejecter:)
+  func getUserContext(resolve: @escaping RCTPromiseResolveBlock,
+                      reject: @escaping RCTPromiseRejectBlock) {
+    let userContext = coralogixRum?.getUserContext()
+    resolve(userContext?.getDictionary())
+  }
+
+  @objc(setLabels:withResolver:withRejecter:)
+  func setLabels(labelsMap: NSDictionary,
+                 resolve:RCTPromiseResolveBlock,
+                 reject:RCTPromiseRejectBlock) -> Void {
+    let labels = labelsMap as? [String: String] ?? [String: String]()
+    resolve(coralogixRum?.setLabels(labels: labels))
+  }
+
+  @objc(getLabels:withRejecter:)
+  func getLabels(resolve: @escaping RCTPromiseResolveBlock,
+                 reject: @escaping RCTPromiseRejectBlock) {
+    if let labels = coralogixRum?.getLabels() {
+      resolve(labels) // Assuming labels is a Dictionary or Array
+    } else {
+      reject("GET_LABELS_ERROR", "Failed to retrieve labels", nil)
+    }
+  }
+
+  @objc(setNetworkRequestContext:withResolver:withRejecter:)
+  func setNetworkRequestContext(networkRequestContext: NSDictionary,
+                                resolve:RCTPromiseResolveBlock,
+                                reject:RCTPromiseRejectBlock) -> Void {
+    guard let dictionary: [String: Any]  = networkRequestContext as? [String: Any] else {
+      reject("Invalid networkRequestContext", "networkRequestContext is not a dictionary", nil)
+      return
+    }
+    coralogixRum?.setNetworkRequestContext(dictionary: dictionary)
+    resolve("setNetworkRequestContext success")
+  }
+
+  @objc(isInited:withRejecter:)
+  func isInited(resolve: @escaping RCTPromiseResolveBlock,
+                reject: @escaping RCTPromiseRejectBlock) {
+    if let isInit = coralogixRum?.isInitialized() {
+      resolve(isInit)
+    } else {
+      reject("IS_INITED", "Failed to retrieve isInited", nil)
+    }
+  }
+
+  @objc(setViewContext:withResolver:withRejecter:)
+  func setViewContext(viewContext: String,
+                      resolve:RCTPromiseResolveBlock,
+                      reject:RCTPromiseRejectBlock) -> Void {
+    coralogixRum?.setView(name: viewContext)
+    resolve("setViewContext success")
+  }
+
+  @objc(log:message:data:withResolver:withRejecter:)
+  func log(severity: Int,
+           message: String,
+           data: NSDictionary,
+           resolve:RCTPromiseResolveBlock,
+           reject:RCTPromiseRejectBlock) -> Void {
+
+    guard let cxLogSeverity = CoralogixLogSeverity(rawValue: Int(severity)) else {
+      return
+    }
+    let data = data as? [String: Any] ?? [String: Any]()
+    coralogixRum?.log(severity:cxLogSeverity, message: message, data: data)
+    resolve("log success")
+  }
+
+  @objc(setApplicationContext:withResolver:withRejecter:)
+  func setApplicationContext(applicationContext: NSDictionary,
+                             resolve:RCTPromiseResolveBlock,
+                             reject:RCTPromiseRejectBlock) -> Void {
+    guard let dictionary = applicationContext as? [String: Any] else {
+      reject("Invalid applicationContext", "applicationContext is not a dictionary", nil)
+      return
+    }
+    let application: String = dictionary["application"] as? String ?? ""
+    let version: String = dictionary["version"] as? String ?? ""
+    coralogixRum?.setApplicationContext(application: application,
+                                        version: version)
+    resolve("setApplicationContext success")
+  }
+
+  @objc(getSessionId:withRejecter:)
+  func getSessionId(resolve: @escaping RCTPromiseResolveBlock,
+                    reject: @escaping RCTPromiseRejectBlock) -> Void {
+    let sessionId = coralogixRum?.getSessionId()
+    resolve(sessionId)
+  }
+
+  @objc(reportNetworkRequest:withResolver:withRejecter:)
+  func reportNetworkRequest(networkRequestDictionary:NSDictionary,
+                            resolve:RCTPromiseResolveBlock,
+                            reject:RCTPromiseRejectBlock) -> Void {
+    guard let dictionary = networkRequestDictionary as? [String: Any] else {
+      reject("Invalid networkRequestDictionary", "networkRequestDictionary is not a dictionary", nil)
+      return
+    }
+    let cxNetworkDict = toCoralogixNetwork(dictionary: dictionary)
+    coralogixRum?.setNetworkRequestContext(dictionary: cxNetworkDict)
+    resolve("reportNetworkRequest success")
+  }
+
+  @objc(shutdown:withRejecter:)
+  func shutdown(resolve:RCTPromiseResolveBlock,
+                reject:RCTPromiseRejectBlock) -> Void {
+    coralogixRum?.shutdown()
+    resolve("shutdown success")
+  }
+
+  @objc(reportError:withResolver:withRejecter:)
+  func reportError(errorDictionary:NSDictionary,
+                   resolve:@escaping RCTPromiseResolveBlock,
+                   reject:@escaping RCTPromiseRejectBlock) -> Void {
+    guard let dictionary = errorDictionary as? [String: Any] else {
+      reject("Invalid Error Dictionary", "errorDictionary is not a dictionary", nil)
+      return
+    }
+    let stackTrace = (dictionary[Keys.keyStackTrace.rawValue] as? [[String: Any]]) ?? []
+    let message = dictionary[Keys.errorMessage.rawValue] as? String ?? ""
+    let errorType = dictionary[Keys.errorType.rawValue] as? String ?? "5"
+
+    coralogixRum?.reportError(message: message,
+                              stackTrace: stackTrace,
+                              errorType: errorType)
+    resolve("reportError success")
+  }
+
+  @objc(sendCxSpanData:withResolver:withRejecter:)
+  func sendCxSpanData(beforeSendResults: NSArray,
+                          resolve:RCTPromiseResolveBlock,
+                          reject:RCTPromiseRejectBlock) -> Void {
+    guard let beforeSendResults = beforeSendResults as? [[String: Any]] else {
+      reject("Invalid sendBeforeSendData", "sendBeforeSendData is not a dictionary", nil)
+      return
+    }
+    coralogixRum?.sendBeforeSendData(data: beforeSendResults)
+    resolve("sendBeforeSendData success")
+  }
+
+  @objc(reportMobileVitalsMeasurementSet:metrics:withResolver:withRejecter:)
+  func reportMobileVitalsMeasurementSet(type: String, metrics: NSArray,
+                                  resolve:RCTPromiseResolveBlock,
+                                  reject:RCTPromiseRejectBlock) -> Void {
+    let list = self.toHybridMetricList(metrics: metrics)
+    coralogixRum?.reportMobileVitalsMeasurement(type: type, metrics: list)
+    resolve("reportMobileVitalsMeasurement success")
+  }
+
+  @objc(reportMobileVitalsMeasurement:value:units:withResolver:withRejecter:)
+  func reportMobileVitalsMeasurement(type: String, value: Double, units: String,
+                               resolve:RCTPromiseResolveBlock,
+                               reject:RCTPromiseRejectBlock) -> Void {
+    coralogixRum?.reportMobileVitalsMeasurement(type: type, value: value, units: units)
+    resolve("reportMobileVitalsMeasurement success")
+  }
+
+  private func toHybridMetricList(metrics: NSArray) -> [HybridMetric] {
+    let array = metrics as? [[String: Any]] ?? []
+
+    return array.map { dict in
+      let hybridMetric =  HybridMetric(name: dict["name"] as? String ?? "",
+                                       value: dict["value"] as? Double ?? 0.0,
+                                       units: dict["units"] as? String ?? "")
+      return hybridMetric
+    }
+  }
+
+  private func toCoralogixNetwork(dictionary: [String: Any]) -> [String: Any] {
+    var result = [String: Any]()
+    result["url"] = dictionary["url"] as? String ?? ""
+    result["host"] = dictionary["host"] as? String ?? ""
+    result["method"] = dictionary["method"] as? String ?? ""
+    result["status_code"] = dictionary["statusCode"] as? Int ?? 0
+    result["http_response_body_size"] = dictionary["duration"] as? Int ?? 0
+    result["fragments"] = dictionary["fragments"] as? String ?? ""
+    result["schema"] = dictionary["schema"] as? String ?? ""
+    result["customTraceId"] = dictionary["customTraceId"] as? String ?? ""
+    result["customSpanId"] = dictionary["customSpanId"] as? String ?? ""
+    return result
+  }
+
+  private func toCoralogixOptions(parameter: NSDictionary) throws -> CoralogixExporterOptions {
+    guard let publicKey = parameter["public_key"] as? String else {
+      debugPrint("Public Key Missing")
+      throw CxSdkError.invalidPublicKey
+    }
+
+    guard let application = parameter["application"] as? String else {
+      throw CxSdkError.missingParameter
+    }
+
+    guard let domain = parameter["coralogixDomain"] as? String else {
+      throw CxSdkError.missingParameter
+    }
+
+    let coralogixDomain = self.getCoralogixDomain(domain: domain)
+    let labels = parameter["labels"] as? [String: Any] ?? [String: Any]()
+    let instrumentations = parameter["instrumentations"] as? [String: Int] ?? [String: Int]()
+
+    var instrumentationDict: [CoralogixExporterOptions.InstrumentationType: Bool] = [:]
+    for (key, value) in instrumentations {
+      if let instrumentationKey = instrumentationType(from: key) {
+        instrumentationDict[instrumentationKey] = value == 0 ? false : true
+      }
+    }
+
+    let userContext = parameter["user_context"] as? [String: Any]
+    let userMetadata = userContext?["user_metadata"] as? [String: String] ?? [String: String]()
+    let coralogixUser = UserContext(userId: userContext?["user_id"] as? String ?? "",
+                                    userName: userContext?["user_name"] as? String ?? "",
+                                    userEmail:userContext?["user_email"] as? String ?? "",
+                                    userMetadata: userMetadata)
+    let ignoreUrls = (parameter["ignoreUrls"] as? [Any])?.compactMap { $0 as? String } ?? []
+    let ignoreError = (parameter["ignoreErrors"] as? [Any])?.compactMap { $0 as? String } ?? []
+    let options = CoralogixExporterOptions(coralogixDomain: coralogixDomain,
+                                           userContext: coralogixUser,
+                                           environment: parameter["environment"] as? String ?? "",
+                                           application: application,
+                                           version: parameter["version"] as? String ?? "",
+                                           publicKey: publicKey,
+                                           ignoreUrls: ignoreUrls,
+                                           ignoreErrors: ignoreError,
+                                           labels: labels,
+                                           sampleRate: 100,
+                                           mobileVitalsFPSSamplingRate: parameter["fpsSamplingSeconds"] as? Int ?? 300,
+                                           instrumentations: instrumentationDict,
+                                           collectIPData: parameter["collectIPData"] as? Bool ?? true,
+                                           proxyUrl: parameter["proxyUrl"] as? String ?? nil,
+                                           traceParentInHeader: parameter["traceParentInHeader"] as? [String: Any] ?? nil,
+                                           debug: parameter["debug"] as? Bool ?? true)
+
+    return options
+  }
+
+  private func convertToJSCompatibleEvent(event: [String: Any]) -> [String: Any] {
+    var jsEvent: [String: Any] = [:]
+    for (key, value) in event {
+      if let stringValue = value as? String {
+        jsEvent[key] = stringValue
+      } else if let numberValue = value as? NSNumber {
+        jsEvent[key] = numberValue
+      } else if let boolValue = value as? Bool {
+        jsEvent[key] = boolValue
+      } else if let arrayValue = value as? [Any] {
+        jsEvent[key] = arrayValue
+      } else if let dictValue = value as? [String: Any] {
+        jsEvent[key] = dictValue
+      } else if value is NSNull {
+        jsEvent[key] = NSNull()
+      }
+    }
+    return jsEvent
+  }
+
+  private func generateUserContext(parameter: NSDictionary) -> UserContext {
+    let userMetadata = parameter["user_metadata"] as? [String: String] ?? [String: String]()
+    return UserContext(userId: parameter["user_id"] as? String ?? "",
+                       userName: parameter["user_name"] as? String ?? "",
+                       userEmail:parameter["user_email"] as? String ?? "",
+                       userMetadata: userMetadata)
+  }
+
+  private func instrumentationType(from string: String) -> CoralogixExporterOptions.InstrumentationType? {
+    switch string {
+    case "mobile_vitals":
+      return .mobileVitals
+    case "custom":
+      return .custom
+    case "errors":
+      return .errors
+    case "network":
+      return .network
+    case "user_interaction":
+      return .userActions
+    case "anr":
+      return .anr
+    case "lifecycle":
+      return .lifeCycle
+    default:
+      return nil
+    }
+  }
+
+  private func getCoralogixDomain(domain: String) -> CoralogixDomain {
+    switch domain.uppercased() {
+    case "EU1":
+      return .EU1
+    case "EU2":
+      return .EU2
+    case "US1":
+      return .US1
+    case "US2":
+      return .US2
+    case "AP1":
+      return .AP1
+    case "AP2":
+      return .AP2
+    case "AP3":
+      return .AP3
+    case "STAGING":
+      return .STG
+    default:
+      return .US2
+    }
+  }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@coralogix/react-native-plugin",
+  "version": "0.1.0",
+  "description": "Official Coralogix React Native plugin",
+  "license": "Apache-2.0",
+  "author": "Coralogix",
+  "homepage": "https://github.com/coralogix/cx-react-native-plugin",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "official",
+    "coralogix",
+    "sdk",
+    "react-native",
+    "javascript",
+    "typescript",
+    "monitoring",
+    "frontend",
+    "mobile",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "react-native": ">=0.73.8"
+  },
+  "main": "./index.cjs.js",
+  "dependencies": {
+    "@opentelemetry/instrumentation-fetch": "0.203.0",
+    "@opentelemetry/instrumentation": "0.48.0",
+    "@opentelemetry/sdk-trace-web": "1.30.1"
+  },
+  "module": "./index.esm.js",
+  "types": "./index.d.ts"
+}

package/src/CoralogixPropgator.d.ts

@@ -0,0 +1,2 @@
+import { FetchInstrumentationConfig } from '@opentelemetry/instrumentation-fetch';
+export declare const propagateTraceHeaderCorsUrls: (config: FetchInstrumentationConfig) => void;

package/src/consts.d.ts

@@ -0,0 +1,23 @@
+import { CoralogixBrowserSdkConfig } from './model/Types';
+export declare const CORALOGIX_LOGS_URL_SUFFIX = "/browser/v1beta/logs";
+export declare const CORALOGIX_RECORDING_URL_SUFFIX = "/sessionrecording";
+export declare const CoralogixAttributes: {
+    USER_AGENT: string;
+    LOCATION_HREF: string;
+    EVENT_TYPE: string;
+    SEVERITY: string;
+    APPLICATION_CONTEXT: string;
+    USER_CONTEXT: string;
+    SOURCE: string;
+    ERROR: {
+        TYPE: string;
+        STACK: string;
+        MESSAGE: string;
+    };
+    LOG: string;
+    CUSTOM_LABELS: string;
+    TIMESTAMP: string;
+    INTERNAL: string;
+    SSL_DURATION: string;
+};
+export declare const OPTIONS_DEFAULTS: Partial<CoralogixBrowserSdkConfig>;

package/src/index.d.ts

@@ -0,0 +1,10 @@
+import type { CoralogixOtelWebType } from './model/CoralogixOtelWebType';
+export declare const CoralogixRum: CoralogixOtelWebType;
+export { type ApplicationContextConfig } from './model/ApplicationContextConfig';
+export { type ViewContextConfig } from './model/ViewContextConfig';
+export { CoralogixDomain } from './model/CoralogixDomain';
+export { type UserContextConfig } from './model/UserContextConfig';
+export { type CoralogixBrowserSdkConfig, CoralogixLogSeverity, } from './model/Types';
+export { type CoralogixOtelWebOptionsInstrumentations } from './model/CoralogixOtelWebOptionsInstrumentations';
+export { type CustomMeasurement } from './model/CustomMeasurement';
+export { type NetworkRequestDetails } from './model/NetworkRequestDetails';

package/src/instrumentations/error/ErrorInstrumentation.d.ts

@@ -0,0 +1,18 @@
+import { InstrumentationBase, InstrumentationConfig } from '@opentelemetry/instrumentation';
+import { ErrorSource } from './error.enums';
+export declare const getCircularReplacer: () => ((key: any, value: any) => undefined | any);
+export interface CoralogixErrorInstrumentationConfig extends InstrumentationConfig {
+    ignoreErrors?: Array<string | RegExp>;
+}
+export declare class CoralogixErrorInstrumentation extends InstrumentationBase {
+    constructor(config: CoralogixErrorInstrumentationConfig);
+    init(): void;
+    private listenToConsoleError;
+    report(source: ErrorSource, arg: string | Error | Event | Array<any>): void;
+    parseErrorObject: (obj: any) => string;
+    protected reportError(err: Error): void;
+    protected reportString(message: string, firstError?: Error): void;
+    protected getPossibleEventMessage(event: any): string;
+    enable(): void;
+    disable(): void;
+}

package/src/instrumentations/error/error.consts.d.ts

@@ -0,0 +1,7 @@
+export declare const ErrorAttributes: {
+    TYPE: string;
+    STACK: string;
+    MESSAGE: string;
+};
+export declare const ERROR_INSTRUMENTATION_NAME = "errors";
+export declare const ERROR_INSTRUMENTATION_VERSION = "1";

package/src/instrumentations/error/error.enums.d.ts

@@ -0,0 +1,4 @@
+export declare enum ErrorSource {
+    CONSOLE = "console",
+    GLOBAL = "global"
+}

package/src/instrumentations/mobile-vitals/JsRefreshRateSamplerInstrumentation.d.ts

@@ -0,0 +1,8 @@
+type SamplerOptions = {
+    sampleDurationMs?: number;
+    sampleIntervalMs?: number;
+    onSample: (rafRate: number) => void;
+};
+export declare function startJsRefreshRateSampler({ sampleDurationMs, sampleIntervalMs, onSample, }: SamplerOptions): void;
+export declare function stopJsRefreshRateSampler(): void;
+export {};

package/src/instrumentations/mobile-vitals/loopDetectorInstrumentation.d.ts

@@ -0,0 +1,16 @@
+type FrameDropEvent = {
+    /** Total gap between RAF ticks */
+    delta: number;
+    /** Estimated blocking beyond the 60Hz budget */
+    stall: number;
+    /** RAF timestamp (relative, not wall clock) */
+    timestamp: number;
+};
+type JSLoopDetectorConfig = {
+    frameDropThresholdMs?: number;
+    onFrameDrop: (event: FrameDropEvent) => void;
+    onError?: (error: Error) => void;
+};
+export declare function startJSLoopDetector({ frameDropThresholdMs, onFrameDrop, onError, }: JSLoopDetectorConfig): void;
+export declare function stopJSLoopDetector(): void;
+export {};

package/src/instrumentations/network/FetchInstrumentation.d.ts

@@ -0,0 +1,5 @@
+import { FetchInstrumentation, FetchInstrumentationConfig } from '@opentelemetry/instrumentation-fetch';
+export declare class CoralogixFetchInstrumentation extends FetchInstrumentation {
+    constructor(config: FetchInstrumentationConfig);
+    enable(): void;
+}

package/src/instrumentations/network/network.enums.d.ts

@@ -0,0 +1,10 @@
+export declare enum OtelNetworkAttrs {
+    METHOD = "http.method",
+    URL = "http.url",
+    STATUS_CODE = "http.status_code",
+    HOST = "http.host",
+    SCHEME = "http.scheme",
+    STATUS_TEXT = "http.status_text",
+    RESPONSE_CONTENT_LENGTH = "http.response_content_length",
+    OtelNetworkAttrs = "OtelNetworkAttrs"
+}

package/src/logger.d.ts

@@ -0,0 +1,16 @@
+interface LoggerConfig {
+    shouldLog?: boolean;
+    prefix?: string;
+}
+declare class Logger {
+    private _shouldLog;
+    private readonly _prefix;
+    constructor(config?: LoggerConfig);
+    set shouldLog(value: boolean);
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+export declare const logger: Logger;
+export {};

package/src/model/ApplicationContextConfig.d.ts

@@ -0,0 +1,4 @@
+export interface ApplicationContextConfig {
+    application: string;
+    version: string;
+}

package/src/model/CoralogixDomain.d.ts

@@ -0,0 +1,10 @@
+export declare enum CoralogixDomain {
+    EU1 = "EU1",
+    EU2 = "EU2",
+    US1 = "US1",
+    US2 = "US2",
+    AP1 = "AP1",
+    AP2 = "AP2",
+    AP3 = "AP3",
+    STAGING = "staging"
+}

package/src/model/CoralogixOtelWebOptionsInstrumentations.d.ts

@@ -0,0 +1,9 @@
+export interface CoralogixOtelWebOptionsInstrumentations {
+    errors?: boolean;
+    custom?: boolean;
+    mobile_vitals?: boolean;
+    anr?: boolean;
+    lifecycle?: boolean;
+    user_interaction?: boolean;
+    network?: boolean;
+}