musora-content-services 2.108.0 → 2.111.0

package/src/services/sync/manager.ts

@@ -1,5 +1,6 @@
 import BaseModel from './models/Base'
 import { Database } from '@nozbe/watermelondb'
+import { DatabaseAdapter } from '@nozbe/watermelondb/adapters/type'
 import SyncRunScope from './run-scope'
 import { SyncStrategy } from './strategies'
 import { default as SyncStore, SyncStoreConfig } from './store'
@@ -8,10 +9,9 @@ import { ModelClass } from './index'
 import SyncRetry from './retry'
 import SyncContext from './context'
 import { SyncError } from './errors'
-import { SyncConcurrencySafetyMechanism } from './concurrency-safety'
+import { SyncEffect } from './effects'
 import { SyncTelemetry } from './telemetry/index'
-import { inBoundary } from './errors/boundary'
-import createStoresFromConfig from './store-configs'
+import createStoreConfigs from './store-configs'
 import { contentProgressObserver } from '../awards/internal/content-progress-observer'
 
 export default class SyncManager {
@@ -22,11 +22,16 @@ export default class SyncManager {
     if (SyncManager.instance) {
       throw new SyncError('SyncManager already initialized')
     }
+
     SyncManager.instance = instance
     const teardown = instance.setup()
-    return async () => {
+
+    return (force = false) => {
       SyncManager.instance = null
-      await teardown()
+      return teardown(force).catch(error => {
+        SyncManager.instance = instance // restore instance on teardown failure
+        throw error
+      })
     }
   }
 
@@ -43,29 +48,34 @@ export default class SyncManager {
 
   private id: string
   public telemetry: SyncTelemetry
-  private database: Database
   private context: SyncContext
+  private storeConfigsRegistry: Record<string, SyncStoreConfig<any>>
   private storesRegistry: Record<string, SyncStore<any>>
   private runScope: SyncRunScope
   private retry: SyncRetry
-  private strategyMap: { stores: SyncStore<any>[]; strategies: SyncStrategy[] }[]
-  private safetyMap: { stores: SyncStore<any>[]; mechanisms: (() => void)[] }[]
+  private strategyMap: { models: ModelClass[]; strategies: SyncStrategy[] }[]
+  private effectMap: { models: ModelClass[]; effects: SyncEffect[] }[]
+
+  private initDatabase: () => Database
+  private destroyDatabase?: (dbName: string, adapter: DatabaseAdapter) => Promise<void>
 
-  constructor(context: SyncContext, initDatabase: () => Database) {
+  constructor(context: SyncContext, initDatabase: () => Database, destroyDatabase?: (dbName: string, adapter: DatabaseAdapter) => Promise<void>) {
     this.id = (SyncManager.counter++).toString()
 
     this.telemetry = SyncTelemetry.getInstance()!
     this.context = context
 
-    this.database = this.telemetry.trace({ name: 'db:init' }, () => inBoundary(initDatabase)) // todo - can cause undefined??
+    this.initDatabase = initDatabase
+    this.destroyDatabase = destroyDatabase
+
+    this.storeConfigsRegistry = this.registerStoreConfigs(createStoreConfigs())
+    this.storesRegistry = {}
 
     this.runScope = new SyncRunScope()
     this.retry = new SyncRetry(this.context, this.telemetry)
 
-    this.storesRegistry = this.registerStores(createStoresFromConfig(this.createStore.bind(this)))
-
     this.strategyMap = []
-    this.safetyMap = []
+    this.effectMap = []
   }
 
   /**
@@ -75,27 +85,23 @@ export default class SyncManager {
     return this.id
   }
 
-  createStore<TModel extends BaseModel>(config: SyncStoreConfig<TModel>) {
-    return new SyncStore<TModel>(
+  createStore(config: SyncStoreConfig, database: Database) {
+    return new SyncStore(
       config,
       this.context,
-      this.database,
+      database,
       this.retry,
       this.runScope,
       this.telemetry
     )
   }
 
-  registerStores<TModel extends BaseModel>(stores: SyncStore<TModel>[]) {
+  registerStoreConfigs(stores: SyncStoreConfig[]) {
     return Object.fromEntries(
       stores.map((store) => {
         return [store.model.table, store]
       })
-    ) as Record<string, SyncStore<TModel>>
-  }
-
-  storesForModels(models: ModelClass[]) {
-    return models.map((model) => this.storesRegistry[model.table])
+    ) as Record<string, SyncStoreConfig>
   }
 
   createStrategy<T extends SyncStrategy, U extends any[]>(
@@ -105,24 +111,32 @@ export default class SyncManager {
     return new strategyClass(this.context, ...args)
   }
 
-  syncStoresWithStrategies(stores: SyncStore<any>[], strategies: SyncStrategy[]) {
-    this.strategyMap.push({ stores, strategies })
+  registerStrategies(models: ModelClass[], strategies: SyncStrategy[]) {
+    this.strategyMap.push({ models, strategies })
   }
 
-  protectStores(stores: SyncStore<any>[], mechanisms: SyncConcurrencySafetyMechanism[]) {
-    const teardowns = mechanisms.map((mechanism) => mechanism(this.context, stores))
-    this.safetyMap.push({ stores, mechanisms: teardowns })
+  registerEffects(models: ModelClass[], effects: SyncEffect[]) {
+    this.effectMap.push({ models, effects })
   }
 
   setup() {
     this.telemetry.debug('[SyncManager] Setting up')
 
+    // can fail synchronously immediately (e.g., schema/migration validation errors)
+    // or asynchronously (e.g., indexedDB errors synchronously OR asynchronously (!))
+    const database = this.telemetry.trace({ name: 'db:init' }, this.initDatabase)
+
+    Object.entries(this.storeConfigsRegistry).forEach(([table, storeConfig]) => {
+      this.storesRegistry[table] = this.createStore(storeConfig, database)
+    })
+
     this.context.start()
     this.retry.start()
 
-    this.strategyMap.forEach(({ stores, strategies }) => {
+    this.strategyMap.forEach(({ models, strategies }) => {
       strategies.forEach((strategy) => {
-        stores.forEach((store) => {
+        models.forEach((model) => {
+          const store = this.storesRegistry[model.table]
           strategy.onTrigger(store, (reason) => {
             store.requestSync(reason)
           })
@@ -131,22 +145,48 @@ export default class SyncManager {
       })
     })
 
-    contentProgressObserver.start(this.database).catch((error) => {
+    const effectTeardowns = this.effectMap.flatMap(({ models, effects }) => {
+      return effects.map((effect) => effect(this.context, models.map(model => this.storesRegistry[model.table])))
+    });
+
+    contentProgressObserver.start(database).catch((error) => {
       this.telemetry.error('[SyncManager] Failed to start contentProgressObserver', error)
     })
 
-    const teardown = async () => {
+    const teardown = async (force = false) => {
       this.telemetry.debug('[SyncManager] Tearing down')
-      this.runScope.abort()
-      this.strategyMap.forEach(({ strategies }) =>
-        strategies.forEach((strategy) => strategy.stop())
-      )
-      this.safetyMap.forEach(({ mechanisms }) => mechanisms.forEach((mechanism) => mechanism()))
-      contentProgressObserver.stop()
-      this.retry.stop()
-      this.context.stop()
-      await this.database.write(() => this.database.unsafeResetDatabase())
+
+      const clear = (force = false) => {
+        if (force && this.destroyDatabase && database.adapter.dbName && database.adapter.underlyingAdapter) {
+          return this.destroyDatabase(database.adapter.dbName, database.adapter.underlyingAdapter)
+        } else {
+          return database.write(() => database.unsafeResetDatabase())
+        }
+      }
+
+      try {
+        this.runScope.abort()
+        this.strategyMap.forEach(({ strategies }) => strategies.forEach((strategy) => strategy.stop()))
+        effectTeardowns.forEach((teardown) => teardown())
+        this.retry.stop()
+        this.context.stop()
+
+        contentProgressObserver.stop()
+      } catch (error) {
+        // capture, but don't rethrow
+        this.telemetry.capture(error)
+      }
+
+      try {
+        return clear(force);
+      } catch (error) {
+        if (!force) {
+          return clear(true);
+        }
+        throw error
+      }
     }
+
     return teardown
   }
 

package/src/services/sync/repositories/base.ts

@@ -89,13 +89,6 @@ export default class SyncRepository<TModel extends BaseModel> {
     )
   }
 
-  protected async upsertOneRemote(id: RecordId, builder: (record: TModel) => void) {
-    return this.store.telemetry.trace(
-      { name: `upsertOneRemote:${this.store.model.table}`, op: 'upsert' },
-      (span) => this._respondToRemoteWriteOne(() => this.store.upsertOneRemote(id, builder, span), id, span)
-    )
-  }
-
   protected async upsertOne(id: RecordId, builder: (record: TModel) => void, { skipPush = false } = {}) {
     return this.store.telemetry.trace(
       { name: `upsertOne:${this.store.model.table}`, op: 'upsert' },
@@ -213,7 +206,7 @@ export default class SyncRepository<TModel extends BaseModel> {
     const result: SyncReadDTO<TModel, T> = {
       data,
       status: pull?.ok ? 'fresh' : 'stale',
-      pullStatus: pull?.ok ? 'success' : 'failure',
+      pullStatus: pull ? (pull.ok ? 'success' : 'failure') : null,
       lastFetchToken: fetchToken,
     }
     return result

package/src/services/sync/retry.ts

@@ -1,5 +1,5 @@
 import SyncContext from "./context"
-import { SyncResponse } from "./fetch"
+import { SyncResponse, SyncPushResponse } from "./fetch"
 import { SyncTelemetry, Span, StartSpanOptions } from "./telemetry/index"
 
 export default class SyncRetry {
@@ -32,7 +32,7 @@ export default class SyncRetry {
    * Runs the given syncFn with automatic retries.
    * Returns the first successful result or the last failed result after retries.
    */
-  async request<T extends SyncResponse>(spanOpts: StartSpanOptions, syncFn: (span: Span) => Promise<T | void>) {
+  async request<T extends SyncResponse>(spanOpts: StartSpanOptions, syncFn: (span: Span) => Promise<T>) {
     let attempt = 0
 
     while (true) {
@@ -47,7 +47,7 @@ export default class SyncRetry {
       const result = await this.telemetry.trace(spanOptions, span => {
         if (!this.context.connectivity.getValue()) {
           this.telemetry.debug('[Retry] No connectivity - skipping')
-          return { ok: false } as T
+          return { ok: false, failureType: 'fetch', isRetryable: false } as T
         }
 
         return syncFn(span)
@@ -55,7 +55,7 @@ export default class SyncRetry {
 
       if (!result) return result
 
-      if (result.ok) {
+      if (result.ok === true) {
         this.resetBackoff()
         return result
       } else {

package/src/services/sync/store/index.ts

@@ -1,7 +1,7 @@
 import { Database, Q, type Collection, type RecordId } from '@nozbe/watermelondb'
 import { RawSerializer, ModelSerializer } from '../serializers'
 import { ModelClass, SyncToken, SyncEntry,  SyncContext, EpochMs } from '..'
-import { SyncPullResponse, SyncPushResponse, SyncPushFailureResponse, PushPayload } from '../fetch'
+import { SyncPullResponse, SyncPushResponse, SyncPullFetchFailureResponse, PushPayload, SyncStorePushResultSuccess, SyncStorePushResultFailure } from '../fetch'
 import type SyncRetry from '../retry'
 import type SyncRunScope from '../run-scope'
 import EventEmitter from '../utils/event-emitter'
@@ -29,7 +29,7 @@ type SyncPush = (
   signal: AbortSignal
 ) => Promise<SyncPushResponse>
 
-export type SyncStoreConfig<TModel extends BaseModel> = {
+export type SyncStoreConfig<TModel extends BaseModel = BaseModel> = {
   model: ModelClass<TModel>
   comparator?: TModel extends BaseModel ? SyncResolverComparator<TModel> : SyncResolverComparator
   pull: SyncPull
@@ -122,6 +122,17 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     }, { table: this.model.table, reason })
   }
 
+  async requestPush(reason: string) {
+    inBoundary(ctx => {
+      this.telemetry.trace(
+        { name: `sync:${this.model.table}`, op: 'push', attributes: ctx },
+        async span => {
+          await this.pushUnsyncedWithRetry(span)
+        }
+      )
+    }, { table: this.model.table, reason })
+  }
+
   async getLastFetchToken() {
     return (await this.db.localStorage.get<SyncToken | null>(this.lastFetchTokenKey)) ?? null
   }
@@ -210,31 +221,6 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
     })
   }
 
-  async upsertOneRemote(id: RecordId, builder: (record: TModel) => void, span?: Span) {
-    return await this.runScope.abortable(async () => {
-      let record: TModel
-      const existing = await this.queryMaybeDeletedRecords(Q.where('id', id)).then(r => r[0] || null)
-
-      if (existing) {
-        existing._isEditing = true
-        builder(existing)
-        existing._isEditing = false
-        record = existing
-      } else {
-        const attrs = new this.model(this.collection, { id })
-        attrs._isEditing = true
-        builder(attrs)
-        attrs._isEditing = false
-        record = this.collection.disposableFromDirtyRaw(attrs._raw)
-      }
-
-      return await this.pushCoalescer.push(
-        [record],
-        () => this.executePush([record], span)
-      )
-    })
-  }
-
   async upsertSome(builders: Record<RecordId, (record: TModel) => void>, span?: Span, { skipPush = false } = {}) {
     if (Object.keys(builders).length === 0) return []
 
@@ -501,9 +487,11 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
               const currentRecords = await this.queryMaybeDeletedRecords(Q.where('id', Q.oneOf(recordIds)))
               const recordsToPush = currentRecords.filter(r => r._raw.updated_at <= (updatedAtMap.get(r.id) || 0))
 
-              if (recordsToPush.length) {
-                return this.executePush(recordsToPush, span)
+              if (!recordsToPush.length) {
+                return { ok: true, results: [] }
               }
+
+              return this.executePush(recordsToPush, span)
             }
           )
         })
@@ -514,7 +502,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
   private async executePull(span?: Span) {
     if (!this.context.connectivity.getValue()) {
       this.telemetry.debug('[Retry] No connectivity - skipping')
-      return { ok: false } as SyncPushFailureResponse
+      return { ok: false, failureType: 'fetch', isRetryable: false } as SyncPullFetchFailureResponse
     }
 
     return this.telemetry.trace(
@@ -570,7 +558,22 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
         )
 
         if (response.ok) {
-          const successfulResults = response.results.filter((result) => result.type === 'success')
+          const [failedResults, successfulResults] = response.results.reduce((acc, result) => {
+            if (result.type === 'success') {
+              acc[1].push(result)
+            } else {
+              acc[0].push(result)
+            }
+            return acc
+          }, [[], []] as [SyncStorePushResultFailure[], SyncStorePushResultSuccess[]])
+
+          if (failedResults.length) {
+            this.telemetry.warn(
+              `[store:${this.model.table}] Push completed with failed records`,
+              { results: failedResults }
+            )
+          }
+
           const successfulEntries = successfulResults.map((result) => result.entry)
           await this.writeEntries(successfulEntries, false, pushSpan)
 

package/src/services/sync/store/push-coalescer.ts

@@ -4,7 +4,7 @@ import { EpochMs } from ".."
 import { SyncPushResponse } from "../fetch"
 
 type PushIntent = {
-  promise: Promise<void | SyncPushResponse>
+  promise: Promise<SyncPushResponse>
   records: {
     id: RecordId
     updatedAt: EpochMs
@@ -18,7 +18,7 @@ export default class PushCoalescer {
     this.intents = []
   }
 
-  push(records: BaseModel[], pusher: (records: BaseModel[]) => Promise<void | SyncPushResponse>) {
+  push(records: BaseModel[], pusher: (records: BaseModel[]) => Promise<SyncPushResponse>) {
     const found = this.find(records)
 
     if (found) {
@@ -28,7 +28,7 @@ export default class PushCoalescer {
     return this.add(pusher(records), records)
   }
 
-  private add(promise: Promise<void | SyncPushResponse>, records: BaseModel[]) {
+  private add(promise: Promise<SyncPushResponse>, records: BaseModel[]) {
     const intent = {
       promise,
       records: records.map(record => ({

package/src/services/sync/store-configs.ts

@@ -2,18 +2,20 @@ import { SyncStoreConfig } from "./store"
 import { ContentLike, ContentProgress, Practice, UserAwardProgress, PracticeDayNote } from "./models"
 import { handlePull, handlePush, makeFetchRequest } from "./fetch"
 
-import type SyncStore from "./store"
 import type BaseModel from "./models/Base"
 
-export default function createStoresFromConfig(createStore: <TModel extends BaseModel>(config: SyncStoreConfig<TModel>) => SyncStore<TModel>) {
+// keeps type-safety in each entry
+const c = <TModel extends BaseModel>(config: SyncStoreConfig<TModel>) => config
+
+export default function createStoresFromConfig() {
   return [
-    createStore({
+    c({
       model: ContentLike,
       pull: handlePull(makeFetchRequest('/api/content/v1/user/likes')),
       push: handlePush(makeFetchRequest('/api/content/v1/user/likes', { method: 'POST' })),
     }),
 
-    createStore({
+    c({
       model: ContentProgress,
       comparator: (server, local) => {
         if (server.record.progress_percent === 0 || local.progress_percent === 0) {
@@ -26,22 +28,22 @@ export default function createStoresFromConfig(createStore: <TModel extends Base
       push: handlePush(makeFetchRequest('/content/user/progress', { method: 'POST' })),
     }),
 
-    createStore({
+    c({
       model: Practice,
       pull: handlePull(makeFetchRequest('/api/user/practices/v1')),
       push: handlePush(makeFetchRequest('/api/user/practices/v1', { method: 'POST' })),
     }),
 
-    createStore({
+    c({
       model: PracticeDayNote,
       pull: handlePull(makeFetchRequest('/api/user/practices/v1/notes')),
       push: handlePush(makeFetchRequest('/api/user/practices/v1/notes', { method: 'POST' })),
     }),
 
-    createStore({
+    c({
       model: UserAwardProgress,
       pull: handlePull(makeFetchRequest('/api/content/v1/user/awards')),
       push: handlePush(makeFetchRequest('/api/content/v1/user/awards', { method: 'POST' })),
     })
-  ] as unknown as SyncStore<BaseModel>[]
+  ]
 }

package/src/services/sync/telemetry/flood-prevention.ts

@@ -0,0 +1,27 @@
+import { SyncTelemetry, type SentryBrowserOptions } from ".";
+
+export function errorHandler(event: ErrorEvent) {
+  if (SyncTelemetry.getInstance()?.shouldIgnoreException(event.error)) {
+    event.preventDefault() // doesn't reliably work in all browsers - error still logged to console
+  }
+}
+
+export function rejectionHandler(event: PromiseRejectionEvent) {
+  if (SyncTelemetry.getInstance()?.shouldIgnoreRejection(event.reason)) {
+    event.preventDefault()
+  }
+}
+
+type ReturnsUndefined<T extends (...args: any[]) => any> = (...args: Parameters<T>) => ReturnType<T> | undefined
+
+/**
+ * Sentry beforeSend hook to prevent sending events for ignored exceptions,
+ * namely numerous eager watermelon queries that fail after IndexedDB failure
+ */
+export const floodPreventionSentryBeforeSend: ReturnsUndefined<NonNullable<SentryBrowserOptions['beforeSend']>> = (_event, hint) => {
+  if (hint?.originalException && SyncTelemetry.getInstance()?.shouldIgnoreException(hint.originalException)) {
+    return null
+  }
+
+  return undefined
+}

package/src/services/sync/telemetry/index.ts

@@ -15,6 +15,15 @@ export type Span = InjectedSentry.Span
 
 export const SYNC_TELEMETRY_TRACE_PREFIX = 'sync:'
 
+export enum SeverityLevel {
+  DEBUG = 0,
+  INFO = 1,
+  LOG = 2,
+  WARNING = 3,
+  ERROR = 4,
+  FATAL = 5
+}
+
 export class SyncTelemetry {
   private static instance: SyncTelemetry | null = null
 
@@ -33,13 +42,20 @@ export class SyncTelemetry {
 
   private userId: string
   private Sentry: SentryLike;
+  private level: SeverityLevel
+  private pretty: boolean
+
+  private ignorePatterns: (string | RegExp)[] = []
 
   // allows us to know if Sentry shouldn't double-capture a dev-prettified console.error log
   private _ignoreConsole = false
 
-  constructor(userId: string, { Sentry }: { Sentry: SentryLike }) {
+  constructor(userId: string, { Sentry, level, pretty }: { Sentry: SentryLike, level?: keyof typeof SeverityLevel, pretty?: boolean }) {
     this.userId = userId
     this.Sentry = Sentry
+    this.level = typeof level !== 'undefined' && level in SeverityLevel ? SeverityLevel[level] : SeverityLevel.LOG
+    this.pretty = typeof pretty !== 'undefined' ? pretty : true
+
     watermelonLogger.log = (...messages: any[]) => this.log('[Watermelon]', ...messages);
     watermelonLogger.warn = (...messages: any[]) => this.warn('[Watermelon]', ...messages);
     watermelonLogger.error = (...messages: any[]) => this.error('[Watermelon]', ...messages);
@@ -67,8 +83,10 @@ export class SyncTelemetry {
     })
   }
 
-  capture(err: SyncError) {
-    err.markReported()
+  capture(err: Error, context = {}) {
+    const wrapped = err instanceof SyncError ? err : new SyncUnexpectedError((err as Error).message, context);
+
+    wrapped.markReported()
     this.Sentry.captureException(err, err instanceof SyncUnexpectedError ? {
       mechanism: {
         handled: false
@@ -85,33 +103,59 @@ export class SyncTelemetry {
     return this._ignoreConsole
   }
 
+  /**
+   * Ignore messages/errors in the future that match provided patterns
+   */
+  ignoreLike(...patterns: (RegExp | string)[]) {
+    this.ignorePatterns.push(...patterns)
+  }
+
+  shouldIgnoreRejection(reason: any) {
+    const message = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason
+    return this.shouldIgnoreMessage(message)
+  }
+
+  shouldIgnoreException(exception: unknown) {
+    if (exception instanceof Error) {
+      return this.shouldIgnoreMessage(exception.message)
+    }
+
+    return false
+  }
+
+  shouldIgnoreMessages(messages: any[]) {
+    return messages.some(message => {
+      return this.shouldIgnoreMessage(message)
+    })
+  }
+
   debug(...messages: any[]) {
-    console.debug(...this.formattedConsoleMessages(...messages));
+    this.level <= SeverityLevel.DEBUG && !this.shouldIgnoreMessages(messages) && console.debug(...this.formattedConsoleMessages(...messages));
     this.recordBreadcrumb('debug', ...messages)
   }
 
   info(...messages: any[]) {
-    console.info(...this.formattedConsoleMessages(...messages));
+    this.level <= SeverityLevel.INFO && !this.shouldIgnoreMessages(messages) && console.info(...this.formattedConsoleMessages(...messages));
     this.recordBreadcrumb('info', ...messages)
   }
 
   log(...messages: any[]) {
-    console.log(...this.formattedConsoleMessages(...messages));
+    this.level <= SeverityLevel.LOG && !this.shouldIgnoreMessages(messages) && console.log(...this.formattedConsoleMessages(...messages));
     this.recordBreadcrumb('log', ...messages)
   }
 
   warn(...messages: any[]) {
-    console.warn(...this.formattedConsoleMessages(...messages));
+    this.level <= SeverityLevel.WARNING && !this.shouldIgnoreMessages(messages) && console.warn(...this.formattedConsoleMessages(...messages));
     this.recordBreadcrumb('warning', ...messages)
   }
 
   error(...messages: any[]) {
-    console.error(...this.formattedConsoleMessages(...messages));
+    this.level <= SeverityLevel.ERROR && !this.shouldIgnoreMessages(messages) && console.error(...this.formattedConsoleMessages(...messages));
     this.recordBreadcrumb('error', ...messages)
   }
 
   fatal(...messages: any[]) {
-    console.error(...this.formattedConsoleMessages(...messages));
+    this.level <= SeverityLevel.FATAL && !this.shouldIgnoreMessages(messages) && console.error(...this.formattedConsoleMessages(...messages));
     this.recordBreadcrumb('fatal', ...messages)
   }
 
@@ -124,6 +168,10 @@ export class SyncTelemetry {
   }
 
   private formattedConsoleMessages(...messages: any[]) {
+    if (!this.pretty) {
+      return messages
+    }
+
     const date = new Date();
     return [...this.consolePrefix(date), ...messages, ...this.consoleSuffix(date)];
   }
@@ -136,4 +184,18 @@ export class SyncTelemetry {
   private consoleSuffix(date: Date) {
     return [` [${date.toLocaleTimeString()}, ${date.getTime()}]`];
   }
+
+  private shouldIgnoreMessage(message: any) {
+    if (message instanceof Error) message = message.message
+    if (typeof message !== 'string') return false
+
+    return this.ignorePatterns.some(pattern => {
+      if (typeof pattern === 'string') {
+        return message.indexOf(pattern) !== -1
+      } else if (pattern instanceof RegExp) {
+        return pattern.test(message)
+      }
+      return false
+    })
+  }
 }

package/src/services/sync/telemetry/sampling.ts

@@ -38,16 +38,12 @@ export const syncSentryBeforeSendTransaction: ReturnsUndefined<NonNullable<Sentr
 
 // sentry doesn't bother to expose your chosen environment in tracesSampler
 // so we have to make consumers pass in our greedy option
-export const createSyncSentryTracesSampler = (greedy = false) => {
+export const createSyncSentryTracesSampler = () => {
   const sampler: ReturnsUndefined<NonNullable<SentryBrowserOptions['tracesSampler']>> = (context) => {
     if (!context.name.startsWith(SYNC_TELEMETRY_TRACE_PREFIX)) {
       return undefined
     }
 
-    if (greedy) {
-      return true
-    }
-
     const { parentSampled, attributes } = context
 
     if (parentSampled) {
@@ -58,7 +54,7 @@ export const createSyncSentryTracesSampler = (greedy = false) => {
       return userBucketedSampler(attributes.userId as string | number, 0.1)
     }
 
-    return false
+    return undefined
   }
 
   return sampler

package/src/services/user/types.d.ts

@@ -5,13 +5,6 @@ export interface BrandMethodLevels {
   singeo: string
 }
 
-export interface BrandTotalXp {
-  drumeo: string
-  pianote: string
-  guitareo: string
-  singeo: string
-}
-
 export interface BrandTimePracticed {
   drumeo: number
   pianote: number