react-native-nitro-amplitude 0.2.0 → 0.5.0

package/src/native/storage.ts

@@ -26,26 +26,26 @@ export class NitroAnalyticsStorage<T> implements AnalyticsStorage<T> {
   }
 
   async getRaw(key: string): Promise<string | undefined> {
-    return getAmplitudeStorage().get(namespaceKey(this.namespace, key), true);
+    const storage = getAmplitudeStorage();
+    return storage.get(namespaceKey(this.namespace, key), true);
   }
 
   async set(key: string, value: T): Promise<void> {
-    getAmplitudeStorage().set(
-      namespaceKey(this.namespace, key),
-      JSON.stringify(value),
-      true,
-    );
+    const storage = getAmplitudeStorage();
+    storage.set(namespaceKey(this.namespace, key), JSON.stringify(value), true);
   }
 
   async remove(key: string): Promise<void> {
-    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), true);
+    const storage = getAmplitudeStorage();
+    storage.remove(namespaceKey(this.namespace, key), true);
   }
 
   async reset(): Promise<void> {
+    const storage = getAmplitudeStorage();
     const prefix = `${this.namespace}::`;
-    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, true);
+    const keys = storage.getKeysByPrefix(prefix, true);
     if (keys.length > 0) {
-      getAmplitudeStorage().removeBatch(keys, true);
+      storage.removeBatch(keys, true);
     }
   }
 }
@@ -54,26 +54,27 @@ export class NitroExperimentStorage implements ExperimentStorage {
   constructor(private readonly namespace: string) {}
 
   async get(key: string): Promise<string | null> {
-    const value = getAmplitudeStorage().get(
-      namespaceKey(this.namespace, key),
-      true,
-    );
+    const storage = getAmplitudeStorage();
+    const value = storage.get(namespaceKey(this.namespace, key), true);
     return value ?? null;
   }
 
   async put(key: string, value: string): Promise<void> {
-    getAmplitudeStorage().set(namespaceKey(this.namespace, key), value, true);
+    const storage = getAmplitudeStorage();
+    storage.set(namespaceKey(this.namespace, key), value, true);
   }
 
   async delete(key: string): Promise<void> {
-    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), true);
+    const storage = getAmplitudeStorage();
+    storage.remove(namespaceKey(this.namespace, key), true);
   }
 
   async reset(): Promise<void> {
+    const storage = getAmplitudeStorage();
     const prefix = `${this.namespace}::`;
-    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, true);
+    const keys = storage.getKeysByPrefix(prefix, true);
     if (keys.length > 0) {
-      getAmplitudeStorage().removeBatch(keys, true);
+      storage.removeBatch(keys, true);
     }
   }
 }
@@ -82,26 +83,27 @@ export class NitroMemoryStorage implements ExperimentStorage {
   constructor(private readonly namespace: string) {}
 
   async get(key: string): Promise<string | null> {
-    const value = getAmplitudeStorage().get(
-      namespaceKey(this.namespace, key),
-      false,
-    );
+    const storage = getAmplitudeStorage();
+    const value = storage.get(namespaceKey(this.namespace, key), false);
     return value ?? null;
   }
 
   async put(key: string, value: string): Promise<void> {
-    getAmplitudeStorage().set(namespaceKey(this.namespace, key), value, false);
+    const storage = getAmplitudeStorage();
+    storage.set(namespaceKey(this.namespace, key), value, false);
   }
 
   async delete(key: string): Promise<void> {
-    getAmplitudeStorage().remove(namespaceKey(this.namespace, key), false);
+    const storage = getAmplitudeStorage();
+    storage.remove(namespaceKey(this.namespace, key), false);
   }
 
   async reset(): Promise<void> {
+    const storage = getAmplitudeStorage();
     const prefix = `${this.namespace}::`;
-    const keys = getAmplitudeStorage().getKeysByPrefix(prefix, false);
+    const keys = storage.getKeysByPrefix(prefix, false);
     if (keys.length > 0) {
-      getAmplitudeStorage().removeBatch(keys, false);
+      storage.removeBatch(keys, false);
     }
   }
 }

package/src/network.ts

@@ -0,0 +1,258 @@
+import { BaseTransport } from "@amplitude/analytics-core";
+import type { Payload, Response, Transport } from "@amplitude/analytics-core";
+import type { HttpClient, SimpleResponse } from "./experiment/types/transport";
+import { createAmplitudeError } from "./errors";
+
+let networkEnabled = true;
+
+export type DryRunRequest = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  data: string | null;
+  timeoutMillis: number;
+  createdAt: number;
+};
+
+export type DryRunEvent = {
+  serverUrl: string;
+  payload: Payload;
+  createdAt: number;
+};
+
+export type AmplitudeNetworkTiming = {
+  kind: "analytics" | "experiment";
+  url: string;
+  method: string;
+  startedAt: number;
+  finishedAt: number;
+  durationMillis: number;
+  status?: number | string;
+  error?: string;
+};
+
+export type AmplitudeNetworkTimingRecorder = (
+  timing: AmplitudeNetworkTiming,
+) => void;
+
+export type AmplitudeNetworkTimingBuffer = {
+  record: AmplitudeNetworkTimingRecorder;
+  getTimings: () => AmplitudeNetworkTiming[];
+  clear: () => void;
+};
+
+const dryRunRequests: DryRunRequest[] = [];
+const dryRunEvents: DryRunEvent[] = [];
+
+export function setNetworkEnabled(enabled: boolean): void {
+  networkEnabled = enabled;
+}
+
+export function getNetworkEnabled(): boolean {
+  return networkEnabled;
+}
+
+export function clearDryRunTransportRecords(): void {
+  dryRunRequests.length = 0;
+  dryRunEvents.length = 0;
+}
+
+export function getDryRunTransportRecords(): DryRunRequest[] {
+  return dryRunRequests.map((request) => ({ ...request }));
+}
+
+export function getDryRunAnalyticsEvents(): DryRunEvent[] {
+  return dryRunEvents.map((event) => ({
+    ...event,
+    payload: { ...event.payload },
+  }));
+}
+
+export function assertNetworkEnabled(): void {
+  if (!networkEnabled) {
+    throw createAmplitudeError(
+      "network_error",
+      "Amplitude network traffic is disabled",
+    );
+  }
+}
+
+function nowMillis(): number {
+  return typeof performance !== "undefined" && performance.now
+    ? performance.now()
+    : Date.now();
+}
+
+function createTiming(
+  kind: AmplitudeNetworkTiming["kind"],
+  url: string,
+  method: string,
+  startedAt: number,
+  status?: number | string,
+  error?: unknown,
+): AmplitudeNetworkTiming {
+  const finishedAt = nowMillis();
+  return {
+    kind,
+    url,
+    method,
+    startedAt,
+    finishedAt,
+    durationMillis: Math.round((finishedAt - startedAt) * 10) / 10,
+    status,
+    error:
+      error === undefined
+        ? undefined
+        : error instanceof Error
+          ? error.message
+          : String(error),
+  };
+}
+
+export function createNetworkTimingBuffer(
+  limit = 20,
+): AmplitudeNetworkTimingBuffer {
+  const timings: AmplitudeNetworkTiming[] = [];
+  const normalizedLimit = Number.isFinite(limit) && limit > 0 ? limit : 20;
+  return {
+    record: (timing) => {
+      timings.push(timing);
+      while (timings.length > normalizedLimit) {
+        timings.shift();
+      }
+    },
+    getTimings: () => timings.map((timing) => ({ ...timing })),
+    clear: () => {
+      timings.length = 0;
+    },
+  };
+}
+
+export function createTimedAnalyticsTransport(
+  transport: Transport,
+  record: AmplitudeNetworkTimingRecorder,
+): Transport {
+  return {
+    async send(
+      serverUrl: string,
+      payload: Payload,
+      enableRequestBodyCompression?: boolean,
+    ): Promise<Response | null> {
+      const startedAt = nowMillis();
+      try {
+        const response = await transport.send(
+          serverUrl,
+          payload,
+          enableRequestBodyCompression,
+        );
+        record(
+          createTiming(
+            "analytics",
+            serverUrl,
+            "POST",
+            startedAt,
+            response?.status,
+          ),
+        );
+        return response;
+      } catch (error) {
+        record(
+          createTiming(
+            "analytics",
+            serverUrl,
+            "POST",
+            startedAt,
+            undefined,
+            error,
+          ),
+        );
+        throw error;
+      }
+    },
+  };
+}
+
+export function createTimedHttpClient(
+  httpClient: HttpClient,
+  record: AmplitudeNetworkTimingRecorder,
+): HttpClient {
+  return {
+    async request(
+      requestUrl: string,
+      method: string,
+      headers: Record<string, string>,
+      data: string | null,
+      timeoutMillis?: number,
+    ): Promise<SimpleResponse> {
+      const startedAt = nowMillis();
+      try {
+        const response = await httpClient.request(
+          requestUrl,
+          method,
+          headers,
+          data,
+          timeoutMillis,
+        );
+        record(
+          createTiming(
+            "experiment",
+            requestUrl,
+            method,
+            startedAt,
+            response.status,
+          ),
+        );
+        return response;
+      } catch (error) {
+        record(
+          createTiming(
+            "experiment",
+            requestUrl,
+            method,
+            startedAt,
+            undefined,
+            error,
+          ),
+        );
+        throw error;
+      }
+    },
+  };
+}
+
+export class DryRunHttpClient implements HttpClient {
+  async request(
+    requestUrl: string,
+    method: string,
+    headers: Record<string, string>,
+    data: string | null,
+    timeoutMillis = 10000,
+  ): Promise<SimpleResponse> {
+    dryRunRequests.push({
+      url: requestUrl,
+      method,
+      headers: { ...headers },
+      data,
+      timeoutMillis,
+      createdAt: Date.now(),
+    });
+    return {
+      status: 202,
+      body: JSON.stringify({ code: 202, dryRun: true }),
+    };
+  }
+}
+
+export class DryRunTransport extends BaseTransport implements Transport {
+  async send(serverUrl: string, payload: Payload): Promise<Response | null> {
+    dryRunEvents.push({
+      serverUrl,
+      payload: { ...payload },
+      createdAt: Date.now(),
+    });
+    return this.buildResponse({ code: 202, dryRun: true });
+  }
+}
+
+export const dryRunHttpClient = new DryRunHttpClient();
+export const dryRunTransport = new DryRunTransport();

package/src/presets.ts

@@ -0,0 +1,208 @@
+import type {
+  Event,
+  ReactNativeOptions,
+  UserSession,
+} from "@amplitude/analytics-core";
+import { getAnalyticsConnector } from "@amplitude/analytics-core";
+import { createInstance } from "./analytics/react-native-client";
+import type { AmplitudeReactNativeClient } from "./analytics/react-native-client";
+import { NetworkGuardedFetchTransport } from "./analytics/network-guarded-fetch-transport";
+import { isNative } from "./analytics/utils/platform";
+import { Experiment } from "./experiment/factory";
+import type { ExperimentClient } from "./experiment/experimentClient";
+import type { ExperimentConfig } from "./experiment/types/config";
+import type { ExperimentUser } from "./experiment/types/user";
+import { dryRunHttpClient, dryRunTransport } from "./network";
+
+function getStorageModule(): typeof import("./native/storage") {
+  if (isNative()) {
+    return require("./native/storage") as typeof import("./native/storage");
+  }
+  return require("./native/storage.web") as typeof import("./native/storage");
+}
+
+function getAnalyticsTransport() {
+  if (isNative()) {
+    const { nitroTransport } =
+      require("./analytics/nitro-transport") as typeof import("./analytics/nitro-transport");
+    return nitroTransport;
+  }
+  return new NetworkGuardedFetchTransport();
+}
+
+export type DurableAmplitudeStoragePreset = {
+  analytics: Pick<
+    ReactNativeOptions,
+    "storageProvider" | "cookieStorage" | "transportProvider"
+  >;
+  experiment: Pick<ExperimentConfig, "storage">;
+  clear: () => Promise<void>;
+};
+
+export type DurableAmplitudeStoragePresetOptions = {
+  namespace?: string;
+  dryRun?: boolean;
+};
+
+export type AmplitudeCombinedClientConfig = {
+  analyticsApiKey: string;
+  experimentDeploymentKey?: string;
+  userId?: string;
+  instanceName?: string;
+  analytics?: ReactNativeOptions;
+  experiment?: ExperimentConfig;
+  durableStorage?: boolean | DurableAmplitudeStoragePresetOptions;
+  dryRun?: boolean;
+};
+
+export type AmplitudeCombinedClient = {
+  analytics: AmplitudeReactNativeClient;
+  experiment?: ExperimentClient;
+  init: (user?: ExperimentUser) => Promise<AmplitudeCombinedClient>;
+  flush: () => Promise<void>;
+  reset: () => void;
+  getUserId: () => string | undefined;
+  getDeviceId: () => string | undefined;
+};
+
+export type AmplitudeCombinedClientConfigWithExperiment =
+  AmplitudeCombinedClientConfig & {
+    experimentDeploymentKey: string;
+  };
+
+export type AmplitudeCombinedClientWithExperiment = Omit<
+  AmplitudeCombinedClient,
+  "experiment" | "init"
+> & {
+  experiment: ExperimentClient;
+  init: (
+    user?: ExperimentUser,
+  ) => Promise<AmplitudeCombinedClientWithExperiment>;
+};
+
+export function createDurableAmplitudeStoragePreset(
+  options: DurableAmplitudeStoragePresetOptions = {},
+): DurableAmplitudeStoragePreset {
+  const namespace = options.namespace ?? "default";
+  const { NitroAnalyticsStorage, NitroExperimentStorage } = getStorageModule();
+  const analyticsEvents = new NitroAnalyticsStorage<Event[]>(
+    `${namespace}:analytics-events`,
+  );
+  const analyticsSession = new NitroAnalyticsStorage<UserSession>(
+    `${namespace}:analytics-session`,
+  );
+  const experimentVariants = new NitroExperimentStorage(
+    `${namespace}:experiment-variants`,
+  );
+  return {
+    analytics: {
+      storageProvider: analyticsEvents,
+      cookieStorage: analyticsSession,
+      transportProvider: options.dryRun
+        ? dryRunTransport
+        : getAnalyticsTransport(),
+    },
+    experiment: {
+      storage: experimentVariants,
+    },
+    clear: async () => {
+      await analyticsEvents.reset();
+      await analyticsSession.reset();
+      await experimentVariants.reset?.();
+    },
+  };
+}
+
+export function createPersistentAmplitudeConfig(
+  namespaceOrOptions?: string | DurableAmplitudeStoragePresetOptions,
+): DurableAmplitudeStoragePreset {
+  if (typeof namespaceOrOptions === "string") {
+    return createDurableAmplitudeStoragePreset({
+      namespace: namespaceOrOptions,
+    });
+  }
+  return createDurableAmplitudeStoragePreset(namespaceOrOptions);
+}
+
+export function createExperimentUser(user: ExperimentUser): ExperimentUser {
+  return {
+    ...user,
+    user_properties: user.user_properties
+      ? { ...user.user_properties }
+      : undefined,
+    groups: user.groups ? { ...user.groups } : undefined,
+    group_properties: user.group_properties
+      ? { ...user.group_properties }
+      : undefined,
+  };
+}
+
+export function createAmplitudeClient(
+  config: AmplitudeCombinedClientConfigWithExperiment,
+): AmplitudeCombinedClientWithExperiment;
+export function createAmplitudeClient(
+  config: AmplitudeCombinedClientConfig,
+): AmplitudeCombinedClient;
+export function createAmplitudeClient(config: AmplitudeCombinedClientConfig) {
+  const instanceName = config.instanceName ?? "$default_instance";
+  const dryRunEnabled =
+    config.dryRun ||
+    (typeof config.durableStorage === "object" && config.durableStorage.dryRun);
+  const storagePreset =
+    config.durableStorage === false
+      ? undefined
+      : createDurableAmplitudeStoragePreset({
+          namespace:
+            typeof config.durableStorage === "object"
+              ? config.durableStorage.namespace
+              : instanceName,
+          dryRun: dryRunEnabled,
+        });
+  const analytics = createInstance();
+  const experiment =
+    config.experimentDeploymentKey !== undefined
+      ? Experiment.initializeWithAmplitudeAnalytics(
+          config.experimentDeploymentKey,
+          {
+            ...storagePreset?.experiment,
+            ...config.experiment,
+            instanceName,
+            httpClient: dryRunEnabled
+              ? (config.experiment?.httpClient ?? dryRunHttpClient)
+              : config.experiment?.httpClient,
+          },
+        )
+      : undefined;
+  const combined = {
+    analytics,
+    experiment,
+    init: async (user?: ExperimentUser) => {
+      await analytics.init(config.analyticsApiKey, config.userId, {
+        ...storagePreset?.analytics,
+        ...config.analytics,
+        instanceName,
+        transportProvider: dryRunEnabled
+          ? (config.analytics?.transportProvider ?? dryRunTransport)
+          : (config.analytics?.transportProvider ??
+            storagePreset?.analytics.transportProvider),
+      }).promise;
+      if (experiment && user) {
+        experiment.setUser(user);
+      }
+      return combined;
+    },
+    flush: async () => analytics.flush().promise,
+    reset: () => analytics.reset(),
+    getUserId: () => analytics.getUserId(),
+    getDeviceId: () => analytics.getDeviceId(),
+  } as AmplitudeCombinedClient;
+
+  return combined;
+}
+
+export function getConnectorIdentity(instanceName = "$default_instance"): {
+  userId?: string;
+  deviceId?: string;
+} {
+  return getAnalyticsConnector(instanceName).identityStore.getIdentity();
+}