@appmetrica/react-native-analytics 3.2.0 → 3.4.0

package/src/deferredDeeplink.ts

@@ -0,0 +1,11 @@
+export type DeferredDeeplinkError = 'NO_REFERRER' | 'NOT_A_FIRST_LAUNCH' | 'PARSE_ERROR' | 'UNKNOWN';
+
+export interface DeferredDeeplinkListener {
+  onSuccess: (deeplink: string) => void;
+  onFailure: (error: DeferredDeeplinkError, referrer?: string) => void;
+}
+
+export interface DeferredDeeplinkParametersListener {
+  onSuccess: (parameters: Record<string, string>) => void;
+  onFailure: (error: DeferredDeeplinkError, referrer?: string) => void;
+}

package/src/error.ts

@@ -0,0 +1,87 @@
+import { Platform } from 'react-native';
+import React from 'react';
+
+const traceRegex = /^\s*at (.*?) ?\((.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+
+function parseTraceLine(line: string): StackTraceItem | undefined {
+  const parts = traceRegex.exec(line);
+  if (parts === null) {
+    return undefined;
+  }
+  return {
+    fileName: parts[2],
+    methodName: parts[1],
+    column: parts[3],
+    line: parts[4],
+  };
+}
+
+function getRNVersion(): string {
+  const versions = Platform.constants.reactNativeVersion;
+  return versions.major + '.' + versions.minor + '.' + versions.patch;
+}
+
+function getReactVersion(): string {
+  return React.version;
+}
+
+function getPluginEnvironment(): Record<string, string> | undefined {
+  return {
+    reactVersion: getReactVersion(),
+  };
+}
+
+function parseStackTrace(
+  stackTrace?: string
+): Array<StackTraceItem> | undefined {
+  if (stackTrace === undefined) {
+    return undefined;
+  }
+  try {
+    const lines = stackTrace.split('\n');
+    const array: Array<StackTraceItem> = [];
+    lines?.forEach((line: string) => {
+      const item = parseTraceLine(line);
+      if (item !== undefined) {
+        array.push(item);
+      }
+    });
+    return array;
+  } catch(e) {
+    console.log(e);
+    return undefined;
+  }
+}
+
+type StackTraceItem = {
+  fileName?: string;
+  className?: string;
+  methodName?: string;
+  line?: string;
+  column?: string;
+};
+
+export class AppMetricaError {
+  message?: string;
+  stackTrace?: Array<StackTraceItem>;
+  errorName?: string;
+  pluginEnvironment?: Record<string, string>;
+  virtualMachineVersion?: string;
+
+  constructor(errorName?: string, message?: string) {
+    this.errorName = errorName;
+    this.message = message;
+    this.pluginEnvironment = getPluginEnvironment();
+    this.virtualMachineVersion = getRNVersion();
+  }
+
+  static withError(error: Error): AppMetricaError {
+    const newError = new AppMetricaError(error.name, error.message);
+    newError.stackTrace = parseStackTrace(error.stack);
+    return newError;
+  }
+
+  static withObject(error?: Object): AppMetricaError {
+    return new AppMetricaError(undefined, JSON.stringify(error));
+  }
+}

package/src/externalAttribution.ts

@@ -0,0 +1,56 @@
+type ExternalAttributionSource =
+  | 'Adjust'
+  | 'Airbridge'
+  | 'AppsFlyer'
+  | 'Kochava'
+  | 'Singular'
+  | 'Tenjin';
+
+export interface ExternalAttribution {
+  source: ExternalAttributionSource;
+  value: Record<string, object>;
+}
+
+export class ExternalAttributions {
+  static adjust(data: Record<string, any>): ExternalAttribution {
+    return {
+      source: 'Adjust',
+      value: data,
+    };
+  }
+
+  static airbridge(data: Record<string, any>): ExternalAttribution {
+    return {
+      source: 'Airbridge',
+      value: data,
+    };
+  }
+
+  static appsflyer(data: Record<string, any>): ExternalAttribution {
+    return {
+      source: 'AppsFlyer',
+      value: data.data,
+    };
+  }
+
+  static kochava(data: Record<string, any>): ExternalAttribution {
+    return {
+      source: 'Kochava',
+      value: data.raw,
+    };
+  }
+
+  static singular(data: Map<string, object>): ExternalAttribution {
+    return {
+      source: 'Singular',
+      value: Object.fromEntries(data),
+    };
+  }
+
+  static tenjin(data: Record<string, any>): ExternalAttribution {
+    return {
+      source: 'Tenjin',
+      value: data,
+    };
+  }
+}

package/src/index.ts

@@ -2,7 +2,14 @@ import { Linking, NativeModules, Platform } from 'react-native';
 import type { ECommerceEvent } from './ecommerce';
 import type { AdRevenue, Revenue } from './revenue';
 import type { UserProfile } from './userProfile';
+import type { ExternalAttribution } from './externalAttribution';
 import { normalizeAdRevenue } from './utils';
+import { AppMetricaError } from './error';
+import { Reporter, type IReporter, type ReporterConfig } from './reporter';
+import type {
+  DeferredDeeplinkListener,
+  DeferredDeeplinkParametersListener,
+} from './deferredDeeplink';
 
 const LINKING_ERROR =
   `The package '@appmetrica/react-native-analytics' doesn't seem to be linked. Make sure: \n\n` +
@@ -55,7 +62,10 @@ export type AppMetricaConfig = {
   appOpenTrackingEnabled?: boolean;
   userProfileID?: string;
 
-  errorEnvironment?: Record<string, string | undefined>
+  errorEnvironment?: Record<string, string | undefined>;
+  appEnvironment?: Record<string, string | undefined>;
+  maxReportsCount?: number;
+  dispatchPeriodSeconds?: number;
 };
 
 export type PreloadInfo = {
@@ -93,8 +103,14 @@ export const UUID_KEY = 'appmetrica_uuid';
 export * from './ecommerce';
 export * from './revenue';
 export * from './userProfile';
+export * from './externalAttribution';
+export type { IReporter, ReporterConfig } from './reporter';
+export * from './deferredDeeplink';
 
 export default class AppMetrica {
+
+  private static reporters: Map<string, Reporter> = new Map();
+
   static activate(config: AppMetricaConfig) {
     if (!activated) {
       AppMetricaNative.activate(config);
@@ -122,8 +138,24 @@ export default class AppMetrica {
     AppMetricaNative.reportAppOpen(deeplink);
   }
 
-  static reportError(identifier: string, message: string, _reason?: Object) {
-    AppMetricaNative.reportError(identifier, message);
+  static reportError(
+    identifier: string,
+    message?: string,
+    _reason?: Error | Object
+  ) {
+    AppMetricaNative.reportError(
+      identifier,
+      message,
+      _reason instanceof Error ? AppMetricaError.withError(_reason) : AppMetricaError.withObject(_reason)
+    );
+  }
+
+  static reportUnhandledException(error: Error) {
+    AppMetricaNative.reportUnhandledException(AppMetricaError.withError(error));
+  }
+
+  static reportErrorWithoutIdentifier(message: string | undefined, error: Error) {
+    AppMetricaNative.reportErrorWithoutIdentifier(message, AppMetricaError.withError(error));
   }
 
   static reportEvent(eventName: string, attributes?: Record<string, any>) {
@@ -174,10 +206,61 @@ export default class AppMetrica {
   }
 
   static reportUserProfile(userProfile: UserProfile) {
-    AppMetricaNative.reportUserProfile(userProfile)
+    AppMetricaNative.reportUserProfile(userProfile);
   }
 
   static putErrorEnvironmentValue(key: string, value?: string) {
     AppMetricaNative.putErrorEnvironmentValue(key, value);
   }
+
+  static reportExternalAttribution(attribution: ExternalAttribution) {
+    AppMetricaNative.reportExternalAttribution(attribution);
+  }
+
+  static putAppEnvironmentValue(key: string, value?: string) {
+    AppMetricaNative.putAppEnvironmentValue(key, value);
+  }
+
+  static clearAppEnvironment() {
+    AppMetricaNative.clearAppEnvironment();
+  }
+
+  static getReporter(apiKey: string): IReporter {
+    if (AppMetrica.reporters.has(apiKey)) {
+      return AppMetrica.reporters.get(apiKey)!;
+    } else {
+      AppMetricaNative.touchReporter(apiKey);
+      const reporter = new Reporter(apiKey);
+      AppMetrica.reporters.set(apiKey, reporter);
+      return reporter;
+    }
+  }
+
+  static activateReporter(config: ReporterConfig) {
+    AppMetricaNative.activateReporter(config);
+  }
+
+  static getDeviceId(): Promise<string | null> {
+    return AppMetricaNative.getDeviceId();
+  }
+
+  static getUuid(): Promise<string | null> {
+    return AppMetricaNative.getUuid();
+  }
+
+  static requestDeferredDeeplink(listener: DeferredDeeplinkListener) {
+    AppMetricaNative.requestDeferredDeeplink(
+      listener.onFailure,
+      listener.onSuccess
+    );
+  }
+
+  static requestDeferredDeeplinkParameters(
+    listener: DeferredDeeplinkParametersListener
+  ) {
+    AppMetricaNative.requestDeferredDeeplinkParameters(
+      listener.onFailure,
+      listener.onSuccess
+    );
+  }
 }

package/src/reporter.ts

@@ -0,0 +1,126 @@
+import { NativeModules, Platform } from 'react-native';
+import type { UserProfile } from './userProfile';
+import type { AdRevenue, Revenue } from './revenue';
+import type { ECommerceEvent } from './ecommerce';
+import { AppMetricaError } from './error';
+
+const LINKING_ERROR =
+  `The package '@appmetrica/react-native-analytics' doesn't seem to be linked. Make sure: \n\n` +
+  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';
+
+const ReporterNativeModule = NativeModules.AppMetricaReporter
+  ? NativeModules.AppMetricaReporter
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
+
+export interface IReporter {
+  reportError(identifier: string, message?: string, _reason?: Error | Object): void;
+  reportErrorWithoutIdentifier(message: string | undefined, error: Error): void;
+  reportUnhandledException(error: Error): void;
+  reportEvent(eventName: string, attributes?: Record<string, any>): void;
+  pauseSession(): void;
+  resumeSession(): void;
+  sendEventsBuffer(): void;
+  clearAppEnvironment(): void;
+  putAppEnvironmentValue(key: string, value?: string): void;
+  setUserProfileID(userProfileID?: string): void;
+  setDataSendingEnabled(enabled: boolean): void;
+  reportUserProfile(userProfile: UserProfile): void;
+  reportAdRevenue(adRevenue: AdRevenue): void;
+  reportECommerce(event: ECommerceEvent): void;
+  reportRevenue(revenue: Revenue): void;
+}
+
+export class Reporter implements IReporter {
+
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  reportError(identifier: string, message?: string, _reason?: Error | Object) {
+    ReporterNativeModule.reportError(
+      this.apiKey,
+      identifier,
+      message,
+      _reason instanceof Error ? AppMetricaError.withError(_reason) : AppMetricaError.withObject(_reason)
+    );
+  }
+
+  reportErrorWithoutIdentifier(message: string | undefined, error: Error) {
+    ReporterNativeModule.reportErrorWithoutIdentifier(this.apiKey, message, AppMetricaError.withError(error));
+  }
+
+  reportUnhandledException(error: Error) {
+    ReporterNativeModule.reportUnhandledException(this.apiKey, AppMetricaError.withError(error));
+  }
+
+  reportEvent(eventName: string, attributes?: Record<string, any>) {
+    ReporterNativeModule.reportEvent(this.apiKey, eventName, attributes);
+  }
+
+  pauseSession() {
+    ReporterNativeModule.pauseSession(this.apiKey);
+  }
+
+  resumeSession() {
+    ReporterNativeModule.resumeSession(this.apiKey);
+  }
+
+  sendEventsBuffer() {
+    ReporterNativeModule.sendEventsBuffer(this.apiKey);
+  }
+
+  clearAppEnvironment() {
+    ReporterNativeModule.clearAppEnvironment(this.apiKey);
+  }
+
+  putAppEnvironmentValue(key: string, value?: string) {
+    ReporterNativeModule.putAppEnvironmentValue(this.apiKey, key, value);
+  }
+
+  setUserProfileID(userProfileID: string) {
+    ReporterNativeModule.setUserProfileID(this.apiKey, userProfileID);
+  }
+
+  setDataSendingEnabled(enabled: boolean) {
+    ReporterNativeModule.setDataSendingEnabled(this.apiKey, enabled);
+  }
+
+  reportUserProfile(profile: UserProfile) {
+    ReporterNativeModule.reportUserProfile(this.apiKey, profile);
+  }
+
+  reportAdRevenue(adRevenue: AdRevenue) {
+    ReporterNativeModule.reportAdRevenue(this.apiKey, adRevenue);
+  }
+
+  reportECommerce(ecommerce: ECommerceEvent) {
+    ReporterNativeModule.reportECommerce(this.apiKey, ecommerce);
+  }
+
+  reportRevenue(revenue: Revenue) {
+    ReporterNativeModule.reportRevenue(this.apiKey, revenue)
+  }
+}
+
+export type ReporterConfig = {
+  apiKey: string;
+  logs?: boolean;
+  maxReportsInDatabaseCount?: number;
+  sessionTimeout?: number;
+  dataSendingEnabled?: boolean;
+  appEnvironment?: Record<string, string | undefined>;
+  dispatchPeriodSeconds?: number;
+  userProfileID?: string;
+  maxReportsCount?: number;
+}