musora-content-services 2.136.2 → 2.136.4

package/.github/workflows/node.js.yml

@@ -5,9 +5,9 @@ name: Node.js CI
 
 on:
   push:
-    branches: [ "main" ]
+    branches: [ ]
   pull_request:
-    branches: [ "main" ]
+    branches: [ ]
 
 jobs:
   build:

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [2.136.4](https://github.com/railroadmedia/musora-content-services/compare/v2.136.3...v2.136.4) (2026-02-20)
+
+
+### Bug Fixes
+
+* better Sentry logging ([#832](https://github.com/railroadmedia/musora-content-services/issues/832)) ([73bd384](https://github.com/railroadmedia/musora-content-services/commit/73bd38473acb631a9f30d559e403e8f4203bb548))
+
+### [2.136.3](https://github.com/railroadmedia/musora-content-services/compare/v2.136.2...v2.136.3) (2026-02-20)
+
+
+### Bug Fixes
+
+* change query ([#831](https://github.com/railroadmedia/musora-content-services/issues/831)) ([8e7d2a2](https://github.com/railroadmedia/musora-content-services/commit/8e7d2a20cecc6bc134664e72b0c30cc067ba0591))
+
 ### [2.136.2](https://github.com/railroadmedia/musora-content-services/compare/v2.136.1...v2.136.2) (2026-02-19)
 
 ### [2.136.1](https://github.com/railroadmedia/musora-content-services/compare/v2.136.0...v2.136.1) (2026-02-19)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musora-content-services",
-  "version": "2.136.2",
+  "version": "2.136.4",
   "description": "A package for Musoras content services ",
   "main": "src/index.js",
   "type": "module",

package/src/services/sanity.js

@@ -2003,10 +2003,17 @@ export async function fetchScheduledAndNewReleases(
   const sortOrder = getSortOrder(sort, brand)
 
   const query = `
-    *[(_type in [${typesString}] && brand == '${brand}' && ((status in ['published','scheduled'] )||(show_in_new_feed == true)))
-      || (defined(live_event_start_time) && (!defined(live_event_end_time) || live_event_end_time >= '${now}' ) && (brand == '${brand}' || brand == 'musora' && live_global_event) && status in ['scheduled'])]
+    *[show_in_new_feed == true && (
+      (_type in [${typesString}] && brand == '${brand}' && status in ['published','scheduled'])
+      || (
+        defined(live_event_start_time)
+        && (!defined(live_event_end_time) || live_event_end_time >= '${now}' )
+        && brand == '${brand}'
+        && status in ['scheduled']
+      )
+    )]
     [${start}...${end}]
-   | order(published_on asc) {
+    | order(${sortOrder}) {
       "id": railcontent_id,
       title,
       "image": thumbnail.asset->url,

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

@@ -19,14 +19,42 @@ export default class PracticesRepository extends SyncRepository<Practice> {
   }
 
   async trackAutoPractice(contentId: number, date: string, incrementalDurationSeconds: number, skipPush = true) {
-    return await this.upsertOne(Practice.generateAutoId(contentId, date), r => {
+    this.store.telemetry.log('trackUserPractice:before', {
+      now: performance.now(),
+      contentId,
+      date,
+      incrementalDurationSeconds
+    })
+
+    const result = await this.upsertOne(Practice.generateAutoId(contentId, date), r => {
+      const oldDurationSeconds = r.duration_seconds;
+
       r._raw.id = Practice.generateAutoId(contentId, date);
       r.auto = true;
       r.content_id = contentId;
       r.date = date;
 
       r.duration_seconds = Math.min((r.duration_seconds || 0) + incrementalDurationSeconds, 59999);
+
+      this.store.telemetry.log('trackUserPractice:around', {
+        now: performance.now(),
+        contentId,
+        date,
+        incrementalDurationSeconds,
+        before: oldDurationSeconds,
+        after: r.duration_seconds
+      })
     }, { skipPush })
+
+    this.store.telemetry.log('trackUserPractice:after', {
+      now: performance.now(),
+      contentId,
+      date,
+      incrementalDurationSeconds,
+      after: result.data.duration_seconds
+    })
+
+    return result
   }
 
   async recordManualPractice(date: string, durationSeconds: number, details: Partial<Pick<Practice, 'title' | 'instrument_id' | 'category_id' | 'thumbnail_url'>> = {}) {
@@ -49,7 +77,7 @@ export default class PracticesRepository extends SyncRepository<Practice> {
 
   async updateDetails(id: RecordId, details: Partial<Pick<Practice, 'duration_seconds' | 'title' | 'thumbnail_url' | 'category_id' | 'instrument_id'>>) {
     return await this.updateOneId(id, r => {
-      r.duration_seconds = Math.min(details.duration_seconds, 59999) ?? r.duration_seconds;
+      r.duration_seconds = details.duration_seconds !== null ? Math.min(details.duration_seconds, 59999) : r.duration_seconds;
       r.title = details.title ?? r.title;
       r.thumbnail_url = details.thumbnail_url ?? r.thumbnail_url;
       r.category_id = details.category_id ?? r.category_id;

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

@@ -667,7 +667,7 @@ export default class SyncStore<TModel extends BaseModel = BaseModel> {
           if (failedResults.length) {
             this.telemetry.warn(
               `[store:${this.model.table}] Push completed with failed records`,
-              { results: failedResults, resultsJSON: JSON.stringify(failedResults) }
+              { extra: { resultsJSON: JSON.stringify(failedResults) } }
             )
           }
 

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

@@ -10,12 +10,14 @@ export type SentryLike = {
   captureMessage: typeof InjectedSentry.captureMessage
   addBreadcrumb: typeof InjectedSentry.addBreadcrumb
   startSpan: typeof InjectedSentry.startSpan
+  logger: typeof InjectedSentry.logger
 }
 
 export type StartSpanOptions = Parameters<typeof InjectedSentry.startSpan>[0]
 export type Span = InjectedSentry.Span
 
 export const SYNC_TELEMETRY_TRACE_PREFIX = 'sync:'
+export const SYNC_TELEMETRY_CONSOLE_PREFIX = '📡 SYNC:'
 
 export enum SeverityLevel {
   DEBUG = 0,
@@ -35,6 +37,13 @@ const severityLevelToSentryLevel: Record<SeverityLevel, 'fatal' | 'error' | 'war
   [SeverityLevel.FATAL]: 'fatal',
 }
 
+type CaptureOptions = {
+  tags?: Record<string, string>
+  contexts?: Record<string, Record<string, unknown>>
+  extra?: unknown
+}
+type LogAttributes = Record<string, unknown>
+
 export class SyncTelemetry {
   private static instance: SyncTelemetry | null = null
 
@@ -58,9 +67,6 @@ export class SyncTelemetry {
 
   private ignorePatterns: (string | RegExp)[] = []
 
-  // allows us to know if Sentry shouldn't double-capture a dev-prettified console.error log
-  private _ignoreConsole = false
-
   constructor(
     userScope: SyncUserScope,
     {
@@ -81,7 +87,7 @@ export class SyncTelemetry {
     this.level = typeof normalizedLevel === 'number' ? normalizedLevel : SeverityLevel.LOG
     this.pretty = typeof pretty !== 'undefined' ? pretty : true
 
-    watermelonLogger.log = (message: unknown) => this.log(message instanceof Error ? message : ['[Watermelon]', message].join(' '))
+    watermelonLogger.log = (message: unknown) => this.log(message instanceof Error ? message.message : ['[Watermelon]', message].join(' '))
     watermelonLogger.warn = (message: unknown) => this.warn(message instanceof Error ? message : ['[Watermelon]', message].join(' '))
     watermelonLogger.error = (message: unknown) => this.error(message instanceof Error ? message : ['[Watermelon]', message].join(' '))
   }
@@ -100,9 +106,9 @@ export class SyncTelemetry {
       let desc = span['_spanId'].slice(0, 4)
       desc += span['_parentSpanId'] ? ` (< ${span['_parentSpanId'].slice(0, 4)})` : ''
 
-      this._log(SeverityLevel.DEBUG, 'info', `[trace:start] ${options.name} (${desc})`, true)
+      this.consoleLog(SeverityLevel.DEBUG, 'info', `[trace:start] ${options.name} (${desc})`)
       const result = callback(span)
-      Promise.resolve(result).finally(() => this._log(SeverityLevel.DEBUG, 'info', `[trace:end] ${options.name} (${desc})`, true))
+      Promise.resolve(result).finally(() => this.consoleLog(SeverityLevel.DEBUG, 'info', `[trace:end] ${options.name} (${desc})`))
 
       return result
     })
@@ -124,88 +130,79 @@ export class SyncTelemetry {
         : undefined
     )
 
-    this._ignoreConsole = true
-    this.error(err instanceof Error ? err.message : String(err))
-    this._ignoreConsole = false
+    this.consoleLog(SeverityLevel.ERROR, 'error', err)
   }
 
-  // allows us to know if Sentry shouldn't double-capture a dev-prettified console.error log
-  shouldIgnoreConsole() {
-    return this._ignoreConsole
+  debug(message: string, attrs?: LogAttributes) {
+    this.logMessage(SeverityLevel.DEBUG, 'info', message, attrs)
   }
 
-  /**
-   * Ignore messages/errors in the future that match provided patterns
-   */
-  ignoreLike(...patterns: (RegExp | string)[]) {
-    this.ignorePatterns.push(...patterns)
+  info(message: string, attrs?: LogAttributes) {
+    this.logMessage(SeverityLevel.INFO, 'info', message, attrs)
   }
 
-  shouldIgnoreRejection(reason: any) {
-    const message = reason instanceof Error ? `${reason.name}: ${reason.message}` : reason
-    return this.shouldIgnoreMessage(message)
+  log(message: string, attrs?: LogAttributes) {
+    this.logMessage(SeverityLevel.LOG, 'log', message, attrs)
   }
 
-  shouldIgnoreException(exception: unknown) {
-    if (exception instanceof Error) {
-      return this.shouldIgnoreMessage(exception.message)
-    }
-
-    return false
+  warn(message: unknown, opts?: CaptureOptions) {
+    this.captureError(SeverityLevel.WARNING, 'warn', message, opts)
   }
 
-  debug(message: unknown, extra?: any) {
-    this._log(SeverityLevel.DEBUG, 'info', message, extra)
+  error(message: unknown, opts?: CaptureOptions) {
+    this.captureError(SeverityLevel.ERROR, 'error', message, opts)
   }
 
-  info(message: unknown, extra?: any) {
-    this._log(SeverityLevel.INFO, 'info', message, extra)
+  fatal(message: unknown, opts?: CaptureOptions) {
+    this.captureError(SeverityLevel.FATAL, 'error', message, opts)
   }
 
-  log(message: unknown, extra?: any) {
-    this._log(SeverityLevel.LOG, 'log', message, extra)
-  }
+  private logMessage(level: SeverityLevel, consoleMethod: 'info' | 'log', message: string, attrs?: LogAttributes) {
+    if (this.level > level) return
+    if (this.shouldIgnoreMessage(message)) return
 
-  warn(message: unknown, extra?: any) {
-    this._log(SeverityLevel.WARNING, 'warn', message, extra)
+    console[consoleMethod](...this.consoleFormattedMessage(message, attrs))
+    const sentryLevel = severityLevelToSentryLevel[level]
+    const sentryLogMethod = sentryLevel === 'debug' ? 'debug' : 'info'
+    this.Sentry.addBreadcrumb({
+      message,
+      data: attrs,
+      level: sentryLevel,
+    })
+    this.Sentry.logger[sentryLogMethod](message, attrs)
   }
 
-  error(message: unknown, extra?: any) {
-    this._log(SeverityLevel.ERROR, 'error', message, extra)
-  }
+  private captureError(level: SeverityLevel, consoleMethod: 'warn' | 'error', error: unknown, opts: CaptureOptions) {
+    if (this.level > level) return
+    if (error instanceof Error && this.shouldIgnoreMessage(error.message)) return
+    if (typeof error === 'string' && this.shouldIgnoreMessage(error)) return
 
-  fatal(message: unknown, extra?: any) {
-    this._log(SeverityLevel.FATAL, 'error', message, extra)
+    console[consoleMethod](...this.consoleFormattedMessage(error, opts))
+    this.Sentry.captureException(error, { level: severityLevelToSentryLevel[level] })
   }
 
-  _log(level: SeverityLevel, consoleMethod: 'info' | 'log' | 'warn' | 'error', message: unknown, extra?: any, skipSentry = false) {
+  private consoleLog(level: SeverityLevel, consoleMethod: 'info' | 'log' | 'warn' | 'error', message: unknown, extra?: any) {
     if (this.level > level || this.shouldIgnoreMessage(message)) return
-    this._ignoreConsole = true
-    console[consoleMethod](...this.formattedConsoleMessage(message, extra))
-    this._ignoreConsole = false
-
-    if (skipSentry) return;
+    console[consoleMethod](...this.consoleFormattedMessage(message, extra))
+  }
 
-    if (level >= SeverityLevel.WARNING) {
-      this.Sentry.captureMessage(message instanceof Error ? message.message : String(message), severityLevelToSentryLevel[level])
-    } else {
-      this.Sentry.addBreadcrumb({ message: message instanceof Error ? message.message : String(message), level: severityLevelToSentryLevel[level] })
-    }
+  static isSyncConsoleMessage(args: unknown[]): boolean {
+    return typeof args[0] === 'string' && args[0].startsWith(SYNC_TELEMETRY_CONSOLE_PREFIX)
   }
 
-  private formattedConsoleMessage(message: unknown, extra: any) {
+  private consoleFormattedMessage(message: unknown, remnant: CaptureOptions | LogAttributes) {
     if (!this.pretty) {
-      return [message, ...(extra ? [extra] : [])]
+      return [message, ...(remnant ? [remnant] : [])]
     }
 
     const date = new Date()
-    return [...this.consolePrefix(date), message, ...(extra ? [extra] : []), ...this.consoleSuffix(date)]
+    return [...this.consolePrefix(date), message, ...(remnant ? [remnant] : []), ...this.consoleSuffix(date)]
   }
 
   private consolePrefix(date: Date) {
     const now = Math.round(date.getTime() / 1000).toString()
     return [
-      `📡 SYNC: (%c${now.slice(0, 5)}%c${now.slice(5, 10)})`,
+      `${SYNC_TELEMETRY_CONSOLE_PREFIX} (%c${now.slice(0, 5)}%c${now.slice(5, 10)})`,
       'color: #ccc',
       'font-weight: bold;',
     ]
@@ -215,6 +212,23 @@ export class SyncTelemetry {
     return [` [${date.toLocaleTimeString()}, ${date.getTime()}]`]
   }
 
+  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
+  }
+
   private shouldIgnoreMessage(message: any) {
     if (message instanceof Error) message = message.message
     if (typeof message !== 'string') return false

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

@@ -6,7 +6,8 @@ type BeforeSendResult<T> = T | PromiseLike<T | null> | null | undefined
 type SamplerResult = number | boolean | undefined
 
 export const syncSentryBeforeSend = (event: ErrorEvent, hint: EventHint): BeforeSendResult<ErrorEvent> => {
-  if (event.logger === 'console' && SyncTelemetry.getInstance()?.shouldIgnoreConsole()) {
+  const consoleArgs = event.extra?.arguments as unknown[] | undefined
+  if (event.logger === 'console' && consoleArgs && SyncTelemetry.isSyncConsoleMessage(consoleArgs)) {
     return null
   }