@goliapkg/sentori-react-native 1.0.0 → 1.2.0

package/src/config.ts

@@ -1,3 +1,22 @@
+import type { LogLevel } from '@goliapkg/sentori-core';
+
+/**
+ * Optional structured signal handed to `onReady` after init
+ * completes. Host wires the callback if they want to know the SDK
+ * is live (alternative to scanning console).
+ */
+export type ReadyInfo = {
+  /** npm version string of @goliapkg/sentori-react-native */
+  sdkVersion: string;
+  /** Milliseconds between RN cold-start signal and SDK init
+   *  completion. May be undefined if native module wasn't bound. */
+  coldStartMs?: number;
+  /** Native module status. `bound: false` means screenshot /
+   *  wireframe / native crash capture won't fire — useful for
+   *  host to know if e.g. they forgot to autolink. */
+  native: { bound: boolean; methods: string[] };
+};
+
 export type Config = {
   token: string;
   release: string;
@@ -10,10 +29,28 @@ export type Config = {
    *  `null` = keep everything (default). */
   errorSampleRate: null | number;
   traceSampleRate: null | number;
+  /** v2.0 — sampling rate for `kind: 'message'` events emitted via
+   *  `captureMessage`. `null` = keep all (default). */
+  messageSampleRate: null | number;
   /** Phase 46: when true, every `captureException` seals the
    *  session-trail buffer and uploads it as a `sessionTrail`
    *  attachment. Defaults to false. */
   sessionTrailEnabled: boolean;
+  /** v2.3 — Sentori console output gate.
+   *
+   *  Default `warn`: SDK is silent on host's console unless
+   *  something is genuinely broken (transport sustained failure,
+   *  native module not found, internal SDK exception). No
+   *  per-tick / per-init / per-breadcrumb noise.
+   *
+   *  Set `'silent'` for absolute silence (e.g. CI smoke runs);
+   *  set `'info'` or `'debug'` when debugging Sentori itself. */
+  logLevel?: LogLevel;
+  /** v2.3 — fires once after init completes. Use this to know the
+   *  SDK is live instead of scanning the console. `info` carries
+   *  the native-module bind status + cold-start timing. Host
+   *  wraps any host-side logging here. */
+  onReady?: (info: ReadyInfo) => void;
 };
 
 let _config: Config | null = null;

package/src/heartbeat.ts

@@ -19,6 +19,8 @@
 // (transport-batched); the heartbeat exists *during* the session to
 // signal presence.
 
+import { logger } from '@goliapkg/sentori-core';
+
 import { getConfig } from './config';
 import { getUser } from './capture';
 import { getLastRoute } from './navigation';
@@ -134,10 +136,7 @@ async function send(): Promise<void> {
       method: 'POST',
     });
   } catch (e) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] heartbeat failed (best-effort)', e);
-    }
+    logger.debug('heartbeat', 'failed (best-effort, normal on offline)', e);
   }
 }
 

package/src/index.ts

@@ -3,9 +3,12 @@ import { addBreadcrumb } from './breadcrumbs';
 import {
   captureError,
   captureException,
+  captureMessage,
   captureStep,
   getUser,
   sendUserFeedback,
+  setTag,
+  setTags,
   setUser,
 } from './capture';
 import { ErrorBoundary } from './error-boundary';
@@ -24,9 +27,15 @@ import {
   type TimeToFullDisplayHandle,
 } from './mobile-vitals';
 import { bindState, recordState, unbindState } from './state-snapshots';
-import { startMoment } from '@goliapkg/sentori-core';
+import {
+  startMoment,
+  startSpan,
+  startTrace,
+  withScopedSpan,
+} from '@goliapkg/sentori-core';
 import { getInstallId } from './install-id';
 import { flushMetrics, recordMetric } from './metrics';
+import { close, flush } from './lifecycle';
 import { linkFederatedIdentity, reportPinMismatch, reportSecurity } from './report-security';
 import { flushTrack, track } from './track';
 import { queryTrustScore } from './trust-score';
@@ -42,8 +51,11 @@ export const sentori = {
   addBreadcrumb,
   setUser,
   getUser,
+  setTag,
+  setTags,
   captureError,
   captureException,
+  captureMessage,
   captureStep,
   sendUserFeedback,
   recordMetric,
@@ -57,6 +69,9 @@ export const sentori = {
   linkFederatedIdentity,
   measureFn,
   startMoment,
+  startSpan,
+  startTrace,
+  withScopedSpan,
   bindState,
   recordState,
   unbindState,
@@ -74,6 +89,8 @@ export const sentori = {
   startSession,
   endSession,
   markSessionCrashed,
+  flush,
+  close,
 };
 
 export default sentori;
@@ -83,11 +100,27 @@ export { addBreadcrumb } from './breadcrumbs';
 export {
   captureError,
   captureException,
+  captureMessage,
   captureStep,
   getUser,
   sendUserFeedback,
+  setTag,
+  setTags,
   setUser,
 } from './capture';
+export {
+  startMoment,
+  startSpan,
+  startTrace,
+  withScopedSpan,
+  type SpanContextLike,
+  type StartSpanOptions,
+} from '@goliapkg/sentori-core';
+export { close, flush } from './lifecycle';
+export type {
+  CaptureMessageOptions,
+  MessageLevel,
+} from '@goliapkg/sentori-core';
 export { ErrorBoundary } from './error-boundary';
 export { FeedbackButton, type FeedbackButtonHandle, type FeedbackButtonProps } from './feedback-widget';
 export {
@@ -117,7 +150,7 @@ export {
   markTimeToFullDisplay,
   type TimeToFullDisplayHandle,
 } from './mobile-vitals';
-export { MomentHandle, type MomentProperties, startMoment } from '@goliapkg/sentori-core';
+export { MomentHandle, type MomentProperties } from '@goliapkg/sentori-core';
 export {
   bindState,
   recordState,

package/src/init.ts

@@ -1,4 +1,6 @@
-import { setConfig } from './config';
+import { setLogLevel } from '@goliapkg/sentori-core';
+
+import { type ReadyInfo, setConfig } from './config';
 import { installGlobalHandler } from './handlers/global';
 import { installLifecycleHandler } from './handlers/lifecycle';
 import { installPromiseHandler } from './handlers/promise';
@@ -124,7 +126,20 @@ export type InitOptions = {
   sampling?: {
     errors?: null | number;
     traces?: null | number;
+    /** v2.0 — sampling rate for `kind: 'message'` events emitted
+     *  via `sentori.captureMessage()`. `null` / absent → keep all. */
+    messages?: null | number;
   };
+  /** v2.3 — Sentori SDK's own console output gate. Default `'warn'`:
+   *  SDK is silent unless something is genuinely broken (transport
+   *  sustained failure, native module not found, internal SDK
+   *  exception). Set to `'silent'` for absolute silence; bump to
+   *  `'info'` / `'debug'` when debugging Sentori itself. */
+  logLevel?: import('@goliapkg/sentori-core').LogLevel;
+  /** v2.3 — fires once after init completes. Use this to know the
+   *  SDK is live instead of scanning the console. The `ReadyInfo`
+   *  carries native-module bind status + cold-start timing. */
+  onReady?: (info: ReadyInfo) => void;
 };
 
 const DEFAULT_INGEST_URL = 'https://ingest.sentori.golia.jp';
@@ -137,6 +152,11 @@ export const init = (options: InitOptions): void => {
     throw new Error('Sentori: release is required');
   }
 
+  // v2.3 — set log level FIRST so any startup-time logger calls
+  // are gated correctly. Default 'warn' from logger.ts; an explicit
+  // host setting overrides.
+  setLogLevel(options.logLevel);
+
   const env =
     options.environment ??
     (typeof __DEV__ !== 'undefined' && __DEV__ ? 'dev' : 'prod');
@@ -163,6 +183,7 @@ export const init = (options: InitOptions): void => {
     screenshotsEnabled: options.capture?.screenshot === true,
     errorSampleRate: options.sampling?.errors ?? null,
     traceSampleRate: options.sampling?.traces ?? null,
+    messageSampleRate: options.sampling?.messages ?? null,
     sessionTrailEnabled: options.capture?.sessionTrail === true,
   });
 
@@ -312,8 +333,44 @@ export const init = (options: InitOptions): void => {
       void markLaunchCompleted(getBundleInfo()?.id ?? null);
     }, 2_000);
   }
+
+  // v2.3 — onReady callback. Fires after setConfig + native bind +
+  // transport start are all settled. The drain-pending work is
+  // still in flight (it's async) but the SDK is ready to accept
+  // new captures. Host wires this to know the SDK is live without
+  // scanning the console. Wrapped in try/catch — host callback
+  // throwing must not propagate (NEVER rule).
+  if (options.onReady) {
+    const nativeMod = (() => {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { native } = require('./native');
+        const n = native?.();
+        return n ?? null;
+      } catch {
+        return null;
+      }
+    })();
+    const info: ReadyInfo = {
+      sdkVersion: SDK_VERSION,
+      coldStartMs: coldMs ?? undefined,
+      native: {
+        bound: !!nativeMod,
+        methods: nativeMod ? Object.keys(nativeMod).sort() : [],
+      },
+    };
+    try {
+      options.onReady(info);
+    } catch {
+      // Host's onReady threw. NEVER rule — swallow.
+    }
+  }
 };
 
+// Bumped on each SDK release; surfaced in onReady payload + the
+// future Sentry-compat layer's identification string.
+const SDK_VERSION = '2.3.0';
+
 /**
  * Phase 42 sub-E.05: shape of each entry in the native crash JSON's
  * `_pendingAttachments` array. Mirrors what

package/src/lifecycle.ts

@@ -0,0 +1,76 @@
+// v2.0 W3 — top-level lifecycle: flush / close.
+//
+// Sentry / OTel parity: a single `flush(timeoutMs?)` that drains
+// every in-flight buffer (events / metrics / track), gated by a
+// timeout so a slow network doesn't hang the host's shutdown path.
+//
+// Use before short-lived process exit (CLI / serverless function /
+// fixture cleanup) to ensure pending captures land before the
+// process dies.
+
+import { flush as flushTransport } from './transport';
+import { flushMetrics } from './metrics';
+import { flushTrack } from './track';
+import { reportInternal } from '@goliapkg/sentori-core';
+
+let _closed = false;
+
+/**
+ * Force-flush every pending Sentori buffer (events, metrics,
+ * track). Returns when the flush settles or the timeout fires —
+ * whichever happens first.
+ *
+ * Never rejects: per the NEVER rule, individual flush failures
+ * are silently absorbed (and self-reported via the internal
+ * circuit-breaker), and the resolved promise's value is undefined.
+ *
+ *     await sentori.flush(5_000)   // wait up to 5 s, then move on
+ *     process.exit(0)
+ */
+export async function flush(timeoutMs: number = 5_000): Promise<void> {
+  if (_closed) return;
+  try {
+    const drainAll = Promise.all([
+      flushTransport().catch((err) => {
+        reportInternal('flush.transport', err);
+      }),
+      flushMetrics().catch((err) => {
+        reportInternal('flush.metrics', err);
+      }),
+      flushTrack().catch((err) => {
+        reportInternal('flush.track', err);
+      }),
+    ]).then(() => undefined);
+    const timer = new Promise<void>((resolve) => setTimeout(resolve, timeoutMs));
+    await Promise.race([drainAll, timer]);
+  } catch (err) {
+    // Belt-and-braces: even though each branch already has its own
+    // catch, the wrapping race shouldn't be able to surface a
+    // failure to the host either. NEVER rule.
+    reportInternal('flush', err);
+  }
+}
+
+/**
+ * Flush + shut down. After `close()`, further capture* calls remain
+ * silent no-ops via `_closed` gate. Idempotent — re-calling is safe.
+ *
+ *     await sentori.close()
+ *     // SDK is asleep; no more events go out.
+ */
+export async function close(timeoutMs?: number): Promise<void> {
+  await flush(timeoutMs);
+  _closed = true;
+}
+
+/** Test hook — reset the shutdown latch so unit tests don't have to
+ *  re-init the whole SDK between cases. */
+export function __resetLifecycleForTests(): void {
+  _closed = false;
+}
+
+/** Internal — capture* implementations check this to short-circuit
+ *  after `close()`. */
+export function isClosed(): boolean {
+  return _closed;
+}

package/src/metrics.ts

@@ -27,16 +27,34 @@ const FLUSH_INTERVAL_MS = 30_000;
 let _buf: Point[] = [];
 let _timer: ReturnType<typeof setInterval> | null = null;
 
+/**
+ * Record a numeric metric point. Cheap to call from a render hook —
+ * pushes into a 500-slot ring drained every 30 s (or on overflow).
+ *
+ * v2.0 — accepts an optional `parent: SpanContextLike` so a metric
+ * can be correlated to a span. The dashboard span-detail view joins
+ * metric points by `tags.span_id` / `tags.trace_id`.
+ *
+ *     const span = sentori.startSpan({ name: 'db.query users' })
+ *     sentori.recordMetric('db.query.duration_ms', 42, undefined, { parent: span })
+ *     span.end({ status: 'ok' })
+ */
 export function recordMetric(
   name: string,
   value: number,
   tags?: Record<string, string>,
+  opts?: { parent?: { spanId: string; traceId: string } },
 ): void {
   if (!isInitialized()) return;
   if (typeof name !== 'string' || name.length === 0 || name.length > 200) return;
   if (typeof value !== 'number' || !Number.isFinite(value)) return;
   if (tags && Object.keys(tags).length > 20) return;
-  _buf.push({ name, tags, ts: new Date().toISOString(), value });
+  // Merge span-context tags so the dashboard can join metric points
+  // to the span that produced them without a separate schema column.
+  const finalTags: Record<string, string> | undefined = opts?.parent
+    ? { ...(tags ?? {}), span_id: opts.parent.spanId, trace_id: opts.parent.traceId }
+    : tags;
+  _buf.push({ name, tags: finalTags, ts: new Date().toISOString(), value });
   if (_buf.length >= MAX_BUFFER) {
     void flushMetrics();
   }

package/src/native.ts

@@ -4,6 +4,8 @@
  * this keeps the SDK usable in pure-JS environments (jest, bun test, web).
  */
 
+import { logger } from '@goliapkg/sentori-core'
+
 declare const __DEV__: boolean | undefined
 
 type SentoriNativeModule = {
@@ -139,15 +141,11 @@ function native(): SentoriNativeModule | null {
       // distinguish "pod is stale" from "method exists but throws
       // at runtime" in one log line.
       const keys = Object.keys(_native as object).sort()
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] native module bound; exposed methods:', keys.join(', ') || '(none)')
+      logger.debug('native', 'module bound; methods:', keys.join(', ') || '(none)')
     }
   } catch (e) {
     _native = null
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] requireNativeModule("Sentori") threw', e)
-    }
+    logger.error('native', 'requireNativeModule("Sentori") threw', e)
   }
   return _native
 }
@@ -292,37 +290,21 @@ export async function captureNativeScreenshotWithMask(
 ): Promise<null | { base64: string; mediaType: string }> {
   const n = native()
   if (!n) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[sentori] native module not bound — requireNativeModule("Sentori") threw',
-      )
-    }
+    logger.warn('native', 'module not bound — requireNativeModule("Sentori") threw')
     return null
   }
   if (!n.captureScreenshotWithMask) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[sentori] native.captureScreenshotWithMask missing — pod install may be stale',
-      )
-    }
+    logger.warn('native', 'captureScreenshotWithMask missing — pod install may be stale')
     return null
   }
   try {
     const r = await n.captureScreenshotWithMask(maskedIds)
-    if (!r && typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[sentori] native screenshot returned null — no key window / render failed',
-      )
+    if (!r) {
+      logger.debug('native', 'screenshot returned null — no key window / render failed')
     }
     return r
   } catch (e) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] native screenshot threw', e)
-    }
+    logger.warn('native', 'screenshot threw', e)
     return null
   }
 }
@@ -413,10 +395,7 @@ export function probeNativeWireframe(): {
       windowCount: typeof r?.windowCount === 'number' ? r.windowCount : 0,
     }
   } catch (e) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] probeWireframe threw', e)
-    }
+    logger.warn('native', 'probeWireframe threw', e)
     return {
       available: false,
       lastDepthMax: 0,
@@ -472,10 +451,7 @@ export function probeNativeScreenshot(): {
     const lastPath = typeof raw.lastPath === 'string' ? raw.lastPath : 'unknown'
     return { available: true, lastPath, raw }
   } catch (e) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] probeScreenshot threw', e)
-    }
+    logger.warn('native', 'probeScreenshot threw', e)
     return { available: false, lastPath: 'native.threw', raw: {} }
   }
 }

package/src/replay.ts

@@ -15,7 +15,7 @@
 //
 // Wire schema: docs/replay-encoding-v2.md.
 
-import { startSpan } from '@goliapkg/sentori-core';
+import { logger, startSpan } from '@goliapkg/sentori-core';
 
 import { getRegisteredMaskQuery } from './mask';
 import { describeWireframeNative } from './native';
@@ -99,22 +99,16 @@ export function startReplay(opts: ReplayOptions): void {
   if (opts.mode !== 'wireframe') return;
   const info = describeWireframeNative();
   if (!info.bound) {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[sentori] replay: Sentori native module not bound (expo-modules-core) — replay attachments will stay empty',
-      );
-    }
-    return;
-  }
-  if (typeof __DEV__ !== 'undefined' && __DEV__) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      '[sentori] replay: starting',
-      'bound=', info.bound,
-      'hasCaptureWireframe=', info.hasCaptureWireframe,
+    logger.warn(
+      'replay',
+      'native module not bound (expo-modules-core); replay attachments will stay empty',
     );
+    return;
   }
+  logger.debug(
+    'replay',
+    'starting; bound=', info.bound, 'hasCaptureWireframe=', info.hasCaptureWireframe,
+  );
   _running = true;
   _nativeMod = loadNativeReplay();
   _keyframeIntervalMs = opts.keyframeMs ?? KEYFRAME_INTERVAL_MS;
@@ -123,12 +117,10 @@ export function startReplay(opts: ReplayOptions): void {
   _timer = setInterval(() => {
     captureTick();
   }, period);
-  if (typeof __DEV__ !== 'undefined' && __DEV__) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      '[sentori] replay: scheduled tick period=', period, 'ms keyframe=', _keyframeIntervalMs, 'ms',
-    );
-  }
+  logger.debug(
+    'replay',
+    'scheduled; tick period=', period, 'ms keyframe=', _keyframeIntervalMs, 'ms',
+  );
 }
 
 export function stopReplay(): void {
@@ -157,9 +149,8 @@ const THIN_RESULT_NODES = 6;
 
 function captureTick(): void {
   if (!_running) return;
-  if (typeof __DEV__ !== 'undefined' && __DEV__ && !_firstTickLogged) {
-    // eslint-disable-next-line no-console
-    console.warn('[sentori] replay tick: FIRST INVOCATION');
+  if (!_firstTickLogged) {
+    logger.debug('replay', 'tick: first invocation');
     _firstTickLogged = true;
   }
   let tickSpan: ReturnType<typeof startSpan> | null = null;
@@ -181,10 +172,7 @@ function captureTick(): void {
     try {
       snapshot = JSON.parse(snapshotJson) as NativeFrame;
     } catch (e) {
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.warn('[sentori] replay tick: native JSON parse failed', e);
-      }
+      logger.warn('replay', 'tick: native JSON parse failed', e);
       tickSpan?.finish({ status: 'error' });
       return;
     }
@@ -201,10 +189,7 @@ function captureTick(): void {
   } catch (e) {
     if (e instanceof Error) tickSpan?.setTag('error.message', e.message);
     tickSpan?.finish({ status: 'error' });
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn('[sentori] replay tick: threw', e);
-    }
+    logger.warn('replay', 'tick threw', e);
   }
 }
 
@@ -302,18 +287,17 @@ export function computeDelta(prev: Map<string, Node>, curr: Map<string, Node>):
 }
 
 function handleEmptyTick(snapshot: unknown): void {
-  if (typeof __DEV__ === 'undefined' || !__DEV__) return;
   _emptyTickCount += 1;
   if (_emptyTickCount === 1 || _emptyTickCount === _emptyTickLogStride) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      '[sentori] replay tick: native returned',
+    logger.debug(
+      'replay',
+      'tick empty — native returned',
       snapshot === null
         ? 'null'
         : typeof snapshot === 'string'
           ? `empty (length=${snapshot.length})`
           : typeof snapshot,
-      `(empty ticks so far: ${_emptyTickCount})`,
+      `(empty so far: ${_emptyTickCount})`,
     );
     _emptyTickLogStride = Math.max(_emptyTickLogStride * 10, 10);
   }
@@ -326,9 +310,9 @@ function diagnosticForTick(snapshot: NativeFrame, snapshotBytes: number): void {
   if (isThin) {
     _thinTickCount += 1;
     if (_thinTickCount === 1 || _thinTickCount === _thinTickLogStride) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        `[sentori] replay tick: thin result nodes=${nodeCount} sizeBytes=${snapshotBytes} (thin ticks so far: ${_thinTickCount})`,
+      logger.debug(
+        'replay',
+        `tick thin: nodes=${nodeCount} sizeBytes=${snapshotBytes} (thin so far: ${_thinTickCount})`,
       );
       _thinTickLogStride = Math.max(_thinTickLogStride * 10, 10);
     }
@@ -337,10 +321,7 @@ function diagnosticForTick(snapshot: NativeFrame, snapshotBytes: number): void {
     _thinTickLogStride = 1;
   }
   if (_okTickCount === 1) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      `[sentori] replay tick: first ok — nodes=${nodeCount} sizeBytes=${snapshotBytes}`,
-    );
+    logger.debug('replay', `first ok tick — nodes=${nodeCount} sizeBytes=${snapshotBytes}`);
   }
 }
 

package/src/transport.ts

@@ -1,4 +1,4 @@
-import { addBreadcrumb, drainSpans } from '@goliapkg/sentori-core';
+import { addBreadcrumb, drainSpans, logger } from '@goliapkg/sentori-core';
 
 import { getConfig } from './config';
 import { isLiveMode } from './control-channel';
@@ -430,15 +430,11 @@ export const uploadAttachment = async (
       // doesn't have to guess between 413/422/500. Pre-rc.6 only
       // the breadcrumb carried the reason; logcat only saw the
       // generic `upload returned null` line.
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.warn(
-          '[sentori] attachment upload non-2xx',
+      logger.debug('transport', 'attachment upload non-2xx',
           'eventId=', eventId,
           'kind=', kind,
           'status=', resp.status,
         );
-      }
       return null;
     }
     const j = (await resp.json().catch(() => null)) as null | {
@@ -449,15 +445,11 @@ export const uploadAttachment = async (
     };
     if (!j || !j.refId) {
       noteAttachmentFailure(eventId, kind, 'bad_response_body');
-      if (typeof __DEV__ !== 'undefined' && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.warn(
-          '[sentori] attachment upload bad-response-body',
+      logger.debug('transport', 'attachment upload bad-response-body',
           'eventId=', eventId,
           'kind=', kind,
           'status=', resp.status,
         );
-      }
       return null;
     }
     return {
@@ -470,15 +462,11 @@ export const uploadAttachment = async (
   } catch (e) {
     const reason = e instanceof Error ? `fetch_${e.name}` : 'fetch_unknown';
     noteAttachmentFailure(eventId, kind, reason);
-    if (typeof __DEV__ !== 'undefined' && __DEV__) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '[sentori] attachment upload fetch threw',
+    logger.debug('transport', 'attachment upload fetch threw',
         'eventId=', eventId,
         'kind=', kind,
         'reason=', reason,
       );
-    }
     return null;
   }
 };