react-native-test-adx 0.1.16 → 0.1.18

package/lib/module/sdkVersion.js

@@ -1,4 +1,4 @@
 "use strict";
 
 /** Keep in sync with package.json "version" (published npm packages ship lib/ only). */
-export const SDK_VERSION = '0.1.16';
+export const SDK_VERSION = '0.1.18';

package/lib/module/services/logging/AdaxonLogger.js

@@ -5,12 +5,16 @@ import { AdaxonSdkError } from "../../errors/AdaxonSdkError.js";
 import { sanitizeLogMetadata } from "./sanitizeLogMetadata.js";
 const DEFAULT_LEVEL = 'info';
 
-/** Milestone events that fall back to captureMessage when structured logs are unavailable. */
-const MESSAGE_FALLBACK_EVENTS = new Set(['sdk.initialize.completed', 'sdk.initialize.failed', 'recommendation.response.received', 'ad.displayed', 'ad.show.failed']);
-/** undefined = not loaded yet; null = unavailable in this app bundle */
+/** Milestones + native dev warn/error → Sentry Message when Logs are off. */
+const SENTRY_MESSAGE_EVENTS = new Set(['sdk.initialize.completed', 'sdk.initialize.failed', 'recommendation.response.received', 'ad.displayed', 'ad.dismissed', 'ad.show.failed']);
 let cachedSentryModule;
 let missingSentryPeerWarningShown = false;
-const SENTRY_UNAVAILABLE_HINT = 'Bundled @sentry/react-native could not be loaded. Reinstall react-native-adaxon dependencies and rebuild the native app.';
+function isDevBuild() {
+  return typeof __DEV__ !== 'undefined' && __DEV__;
+}
+function usesSentryLogs(platform) {
+  return platform === 'web' || !isDevBuild();
+}
 function loadSentryModule() {
   if (cachedSentryModule !== undefined) {
     return cachedSentryModule;
@@ -24,14 +28,14 @@ function loadSentryModule() {
   return cachedSentryModule;
 }
 function warnSentryUnavailableOnce(hasDsn) {
-  if (!hasDsn || missingSentryPeerWarningShown || typeof __DEV__ === 'undefined' || !__DEV__) {
+  if (!hasDsn || missingSentryPeerWarningShown || !isDevBuild()) {
     return;
   }
   if (loadSentryModule()) {
     return;
   }
   missingSentryPeerWarningShown = true;
-  console.warn(`[Adaxon] Activity logging is on and Sentry DSN is set, but ${SENTRY_UNAVAILABLE_HINT} ` + 'Until then, events appear locally as [Adaxon activity] in Metro/logcat only.');
+  console.warn('[Adaxon] Activity logging is on and Sentry DSN is set, but @sentry/react-native could not be loaded. ' + 'Reinstall dependencies and rebuild. Until then, use [Adaxon activity] in Metro/logcat.');
 }
 function sentryLevel(level, target) {
   if (level === 'warn') {
@@ -45,27 +49,57 @@ function sentryLevel(level, target) {
   }
   return 'info';
 }
-function shouldCaptureMessage(input, level, structuredLogSent, platform) {
-  if (level === 'debug' || structuredLogSent) {
-    return false;
+
+/** What to send after structured Logs (if any) are attempted. */
+function planSentryDelivery(input, level, platform, sentStructuredLog, ownsSentryClient) {
+  if (level === 'debug') {
+    return {
+      breadcrumb: null,
+      sendMessage: false
+    };
+  }
+  const nativeDev = platform !== 'web' && isDevBuild();
+  let sendMessage = false;
+  if (ownsSentryClient && !sentStructuredLog) {
+    if (input.captureAsEvent && input.error === undefined) {
+      sendMessage = true;
+    } else if (SENTRY_MESSAGE_EVENTS.has(input.eventName)) {
+      sendMessage = true;
+    } else if (nativeDev && (level === 'warn' || level === 'error')) {
+      sendMessage = true;
+    }
   }
-  if (input.captureAsEvent && input.error === undefined) {
-    return true;
+  let breadcrumb = null;
+  if (level === 'warn' || level === 'error') {
+    breadcrumb = 'adaxon.sdk';
+  } else if (nativeDev && !sentStructuredLog && !sendMessage) {
+    breadcrumb = 'adaxon.activity';
   }
-  if (platform === 'web') {
-    return MESSAGE_FALLBACK_EVENTS.has(input.eventName);
+  return {
+    breadcrumb,
+    sendMessage
+  };
+}
+
+/** Never throw or leave a rejected Sentry promise unhandled. */
+function neverBreakSdk(run) {
+  try {
+    const result = run();
+    if (result && typeof result.then === 'function') {
+      Promise.resolve(result).catch(() => undefined);
+    }
+  } catch {
+    // Activity logging must not affect the SDK.
   }
-  // Native dev + release: message fallback when Sentry Logs API did not accept the event.
-  return true;
 }
-function emitStructuredLog(sentry, level, eventName, metadata) {
+function tryStructuredLog(sentry, level, eventName, attributes) {
   try {
     const loggerFn = sentry.logger?.[level];
     if (typeof loggerFn !== 'function') {
       return false;
     }
     loggerFn.call(sentry.logger, eventName, {
-      ...metadata,
+      ...attributes,
       event_name: eventName
     });
     return true;
@@ -73,43 +107,30 @@ function emitStructuredLog(sentry, level, eventName, metadata) {
     return false;
   }
 }
-function sentryInitOptions(dsn, environment) {
-  return {
-    dsn,
-    environment,
-    enableLogs: true,
-    enableAutoConsoleLogs: false,
-    tracesSampleRate: 0,
-    enableAutoSessionTracking: false,
-    sendDefaultPii: false
-  };
+function isUnitTestRun() {
+  const env = globalThis.process?.env;
+  return env?.NODE_ENV === 'test';
 }
-function emitDevActivityMirror(level, eventName, metadata) {
-  if (typeof __DEV__ === 'undefined' || !__DEV__) {
-    return;
+function deferOnNative(platform, run) {
+  const sync = platform === 'web' || isUnitTestRun();
+  if (sync) {
+    run();
+  } else {
+    setTimeout(run, 0);
   }
-  const consoleFn = level === 'error' ? console.error : level === 'warn' ? console.warn : console.info;
-  const write = () => {
-    consoleFn(`[Adaxon activity] ${eventName}`, metadata);
-  };
-  const sentry = loadSentryModule();
-  if (typeof sentry?.consoleSandbox === 'function') {
-    sentry.consoleSandbox(write);
+}
+function mirrorToDevConsole(level, eventName, metadata) {
+  if (!isDevBuild()) {
     return;
   }
-  write();
-}
-function activityTags(eventName, platform) {
-  return {
-    adaxon_event: eventName,
-    adaxon_platform: platform,
-    adaxon_sdk_version: SDK_VERSION
-  };
+  const log = level === 'error' ? console.error : level === 'warn' ? console.warn : console.info;
+  log(`[Adaxon activity] ${eventName}`, metadata);
 }
 class AdaxonLoggerService {
   enabled = false;
   platform = 'web';
   sentryReady = false;
+  ownsSentryClient = false;
   configure(input) {
     this.enabled = Boolean(input.enabled);
     this.platform = input.platform;
@@ -124,6 +145,7 @@ class AdaxonLoggerService {
     this.enabled = false;
     this.sentryReady = false;
     this.platform = 'web';
+    this.ownsSentryClient = false;
     cachedSentryModule = undefined;
     missingSentryPeerWarningShown = false;
   }
@@ -132,71 +154,90 @@ class AdaxonLoggerService {
       return;
     }
     const level = input.level ?? DEFAULT_LEVEL;
-    const metadata = sanitizeLogMetadata({
+    const baseMetadata = {
       ...input.metadata,
       sdk_version: SDK_VERSION,
       platform: this.platform,
       timestamp: new Date().toISOString()
+    };
+    mirrorToDevConsole(level, input.eventName, sanitizeLogMetadata(baseMetadata));
+    const sentryAttributes = sanitizeLogMetadata({
+      ...baseMetadata,
+      event_name: input.eventName
+    }, {
+      forSentry: true
     });
-    const tags = activityTags(input.eventName, this.platform);
-    this.safe(() => {
-      const sentry = loadSentryModule();
-      if (!sentry || !this.sentryReady) {
-        return;
-      }
-      const structuredLogSent = emitStructuredLog(sentry, level, input.eventName, metadata);
-      if (level === 'warn' || level === 'error') {
-        sentry.addBreadcrumb({
-          category: 'adaxon.sdk',
-          message: input.eventName,
-          level: sentryLevel(level, 'breadcrumb'),
-          data: metadata,
-          timestamp: Date.now() / 1000
-        });
-      }
-      if (shouldCaptureMessage(input, level, structuredLogSent, this.platform) && typeof sentry.captureMessage === 'function') {
-        sentry.captureMessage(input.eventName, {
-          level: sentryLevel(level, 'message'),
-          tags,
-          extra: metadata,
-          fingerprint: ['adaxon.activity', input.eventName]
-        });
-      }
-      if (input.captureAsEvent && input.error !== undefined) {
-        const captureError = input.error instanceof Error ? input.error : new Error(AdaxonSdkError.messageOf(input.error, `Adaxon SDK activity: ${input.eventName}`));
-        sentry.captureException(captureError, {
-          tags,
-          extra: metadata
-        });
-      }
-    });
-    emitDevActivityMirror(level, input.eventName, metadata);
+    deferOnNative(this.platform, () => neverBreakSdk(() => this.pushToSentry(input, level, sentryAttributes)));
+  }
+  pushToSentry(input, level, sentryAttributes) {
+    const sentry = loadSentryModule();
+    if (!sentry || !this.sentryReady) {
+      return;
+    }
+    const sentStructuredLog = usesSentryLogs(this.platform) && tryStructuredLog(sentry, level, input.eventName, sentryAttributes);
+    const plan = planSentryDelivery(input, level, this.platform, sentStructuredLog, this.ownsSentryClient);
+    const tags = {
+      adaxon_event: input.eventName,
+      adaxon_platform: this.platform,
+      adaxon_sdk_version: SDK_VERSION
+    };
+    if (plan.breadcrumb) {
+      const category = plan.breadcrumb;
+      neverBreakSdk(() => sentry.addBreadcrumb({
+        category,
+        message: input.eventName,
+        level: sentryLevel(level, 'breadcrumb'),
+        data: sentryAttributes,
+        timestamp: Date.now() / 1000
+      }));
+    }
+    if (plan.sendMessage && typeof sentry.captureMessage === 'function') {
+      neverBreakSdk(() => sentry.captureMessage(input.eventName, {
+        level: sentryLevel(level, 'message'),
+        tags,
+        extra: sentryAttributes
+      }));
+    }
+    if (input.captureAsEvent && input.error !== undefined && this.ownsSentryClient) {
+      const err = input.error instanceof Error ? input.error : new Error(AdaxonSdkError.messageOf(input.error, `Adaxon SDK activity: ${input.eventName}`));
+      neverBreakSdk(() => sentry.captureException(err, {
+        tags,
+        extra: sentryAttributes
+      }));
+    }
   }
   ensureSentry(dsn, testMode) {
-    this.safe(() => {
+    neverBreakSdk(() => {
       const sentry = loadSentryModule();
       if (!sentry) {
         return;
       }
+      this.ownsSentryClient = false;
       if (!sentry.getClient()) {
         if (!dsn?.trim()) {
           return;
         }
-        const environment = testMode ? 'adaxon-sdk-test' : 'adaxon-sdk';
-        sentry.init(sentryInitOptions(dsn.trim(), environment));
+        sentry.init({
+          dsn: dsn.trim(),
+          environment: testMode ? 'adaxon-sdk-test' : 'adaxon-sdk',
+          enableLogs: usesSentryLogs(this.platform),
+          enableAutoConsoleLogs: false,
+          enableNative: false,
+          autoInitializeNativeSdk: false,
+          defaultIntegrations: false,
+          integrations: [],
+          tracesSampleRate: 0,
+          enableAutoSessionTracking: false,
+          sendDefaultPii: false
+        });
+        this.ownsSentryClient = true;
+      }
+      for (const [key, value] of [['adaxon_sdk_version', SDK_VERSION], ['adaxon_platform', this.platform]]) {
+        sentry.setTag(key, value);
       }
-      sentry.setTag('adaxon_sdk_version', SDK_VERSION);
-      sentry.setTag('adaxon_platform', this.platform);
       this.sentryReady = true;
     });
   }
-  safe(run) {
-    try {
-      run();
-    } catch {
-      // Logging must never interrupt SDK behavior.
-    }
-  }
 }
 export const AdaxonLogger = new AdaxonLoggerService();
 export function logSdkActivity(input) {

package/lib/module/services/logging/sanitizeLogMetadata.js

@@ -6,19 +6,28 @@ const MAX_NESTED_KEYS = 40;
 function truncate(value) {
   return value.length <= MAX_STRING_LENGTH ? value : `${value.slice(0, MAX_STRING_LENGTH)}…`;
 }
-function sanitizeField(key, value) {
+function sanitizeField(key, value, forSentry) {
   if (SENSITIVE_KEY.test(key)) {
     return '[redacted]';
   }
   if (value === null || value === undefined) {
-    return value;
+    return forSentry ? undefined : value;
   }
   if (typeof value === 'string') {
     return truncate(value);
   }
-  if (typeof value === 'number' || typeof value === 'boolean') {
+  if (typeof value === 'boolean') {
     return value;
   }
+  if (typeof value === 'number') {
+    if (Number.isFinite(value)) {
+      return value;
+    }
+    return forSentry ? undefined : value;
+  }
+  if (forSentry) {
+    return truncate(String(value));
+  }
   if (Array.isArray(value)) {
     return value.map(item => typeof item === 'string' ? truncate(item) : item);
   }
@@ -32,14 +41,19 @@ function sanitizeField(key, value) {
   return String(value);
 }
 
-/** Redact secrets and cap string size before activity logs leave the SDK. */
-export function sanitizeLogMetadata(metadata) {
+/** Redact secrets, cap strings; optional Sentry flattening (primitives only). */
+export function sanitizeLogMetadata(metadata, options = {}) {
   if (!metadata) {
     return {};
   }
+  const forSentry = Boolean(options.forSentry);
   const output = {};
   for (const [key, value] of Object.entries(metadata)) {
-    output[key] = sanitizeField(key, value);
+    const sanitized = sanitizeField(key, value, forSentry);
+    if (forSentry && sanitized === undefined) {
+      continue;
+    }
+    output[key] = sanitized;
   }
   return output;
 }

package/lib/typescript/src/sdkVersion.d.ts

@@ -1,3 +1,3 @@
 /** Keep in sync with package.json "version" (published npm packages ship lib/ only). */
-export declare const SDK_VERSION = "0.1.16";
+export declare const SDK_VERSION = "0.1.18";
 //# sourceMappingURL=sdkVersion.d.ts.map

package/lib/typescript/src/services/logging/AdaxonLogger.d.ts

@@ -18,11 +18,12 @@ declare class AdaxonLoggerService {
     private enabled;
     private platform;
     private sentryReady;
+    private ownsSentryClient;
     configure(input: AdaxonLoggerConfigureInput): void;
     reset(): void;
     logActivity(input: AdaxonActivityLogInput): void;
+    private pushToSentry;
     private ensureSentry;
-    private safe;
 }
 export declare const AdaxonLogger: AdaxonLoggerService;
 export declare function logSdkActivity(input: AdaxonActivityLogInput): void;

package/lib/typescript/src/services/logging/sanitizeLogMetadata.d.ts

@@ -1,3 +1,7 @@
-/** Redact secrets and cap string size before activity logs leave the SDK. */
-export declare function sanitizeLogMetadata(metadata: Record<string, unknown> | undefined): Record<string, unknown>;
+export type SanitizeLogMetadataOptions = {
+    /** Flatten to string/number/boolean for Sentry Logs and captureMessage (React Native). */
+    forSentry?: boolean;
+};
+/** Redact secrets, cap strings; optional Sentry flattening (primitives only). */
+export declare function sanitizeLogMetadata(metadata: Record<string, unknown> | undefined, options?: SanitizeLogMetadataOptions): Record<string, unknown>;
 //# sourceMappingURL=sanitizeLogMetadata.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-test-adx",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Adaxon React Native / Expo SDK for event tracking and offer recommendations.",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",