@atproto/ozone 0.1.173 → 0.1.174

package/src/config/config.ts

@@ -90,6 +90,15 @@ export const envToCfg = (env: OzoneEnvironment): OzoneConfig => {
         }
       : null
 
+  const assignmentsCfg: OzoneConfig['assignments'] = {
+    queueDurationMs: env.assignmentQueueDurationMs ?? 5 * MINUTE,
+    reportDurationMs: env.assignmentReportDurationMs ?? 5 * MINUTE,
+  }
+
+  const statsCfg: OzoneConfig['stats'] = {
+    computerIntervalMinutes: env.statsComputerIntervalMinutes ?? 15,
+  }
+
   return {
     service: serviceCfg,
     db: dbCfg,
@@ -101,6 +110,8 @@ export const envToCfg = (env: OzoneEnvironment): OzoneConfig => {
     blobDivert: blobDivertServiceCfg,
     access: accessCfg,
     verifier: verifierCfg,
+    assignments: assignmentsCfg,
+    stats: statsCfg,
     jetstreamUrl: env.jetstreamUrl,
   }
 }
@@ -115,10 +126,21 @@ export type OzoneConfig = {
   identity: IdentityConfig
   blobDivert: BlobDivertConfig | null
   access: AccessConfig
+  assignments: AssignmentsConfig
+  stats: StatsConfig
   jetstreamUrl?: string
   verifier: VerifierConfig | null
 }
 
+export type StatsConfig = {
+  /**
+   * Minutes between stats computer cycles.
+   * Defaults to 15. Minimum is 1.
+   * Set to -1 to disable the stats computer.
+   */
+  computerIntervalMinutes: number
+}
+
 export type ServiceConfig = {
   port: number
   publicUrl: string
@@ -182,3 +204,8 @@ export type VerifierConfig = {
   jetstreamUrl?: string
   issuersToIndex?: string[]
 }
+
+export type AssignmentsConfig = {
+  queueDurationMs: number
+  reportDurationMs: number
+}

package/src/config/env.ts

@@ -43,6 +43,11 @@ export const readEnv = (): OzoneEnvironment => {
     verifierPassword: envStr('OZONE_VERIFIER_PASSWORD'),
     verifierIssuersToIndex: envList('OZONE_VERIFIER_ISSUERS_TO_INDEX'),
     jetstreamUrl: envStr('OZONE_JETSTREAM_URL'),
+    assignmentQueueDurationMs: envInt('OZONE_ASSIGNMENT_QUEUE_DURATION_MS'),
+    assignmentReportDurationMs: envInt('OZONE_ASSIGNMENT_REPORT_DURATION_MS'),
+    statsComputerIntervalMinutes: envInt(
+      'OZONE_STATS_COMPUTER_INTERVAL_MINUTES',
+    ),
   }
 }
 
@@ -84,4 +89,7 @@ export type OzoneEnvironment = {
   verifierPassword?: string
   verifierIssuersToIndex?: string[]
   jetstreamUrl?: string
+  assignmentQueueDurationMs?: number
+  assignmentReportDurationMs?: number
+  statsComputerIntervalMinutes?: number
 }

package/src/context.ts

@@ -5,6 +5,7 @@ import { AtpAgent } from '@atproto/api'
 import { Keypair, Secp256k1Keypair } from '@atproto/crypto'
 import { DidCache, IdResolver, MemoryCache } from '@atproto/identity'
 import { createServiceAuthHeaders } from '@atproto/xrpc-server'
+import { AssignmentService } from './assignment'
 import { AuthVerifier } from './auth-verifier'
 import { BackgroundQueue } from './background'
 import {
@@ -22,6 +23,8 @@ import {
   ModerationServiceProfileCreator,
 } from './mod-service/profile'
 import { StrikeService, StrikeServiceCreator } from './mod-service/strike'
+import { QueueService, QueueServiceCreator } from './queue/service'
+import { ReportStatsService, ReportStatsServiceCreator } from './report/stats'
 import {
   SafelinkRuleService,
   SafelinkRuleServiceCreator,
@@ -58,6 +61,8 @@ export type AppContextOptions = {
   communicationTemplateService: CommunicationTemplateServiceCreator
   safelinkRuleService: SafelinkRuleServiceCreator
   scheduledActionService: ScheduledActionServiceCreator
+  queueService: QueueServiceCreator
+  reportStatsService: ReportStatsServiceCreator
   setService: SetServiceCreator
   settingService: SettingServiceCreator
   strikeService: StrikeServiceCreator
@@ -73,6 +78,7 @@ export type AppContextOptions = {
   imgInvalidator?: ImageInvalidator
   backgroundQueue: BackgroundQueue
   sequencer: Sequencer
+  assignmentService: AssignmentService
   authVerifier: AuthVerifier
   verificationService: VerificationServiceCreator
   verificationIssuer: VerificationIssuerCreator
@@ -143,6 +149,8 @@ export class AppContext {
       cfg.appview.did,
       createAuthHeaders,
     )
+    const queueService = QueueService.creator()
+    const reportStatsService = ReportStatsService.creator()
     const setService = SetService.creator()
     const settingService = SettingService.creator()
     const strikeService = StrikeService.creator()
@@ -164,6 +172,14 @@ export class AppContext {
       strikeService,
       overrides?.imgInvalidator,
     )
+    const assignmentService = AssignmentService.creator(
+      {
+        queueDurationMs: cfg.assignments.queueDurationMs,
+        reportDurationMs: cfg.assignments.reportDurationMs,
+      },
+      queueService,
+      teamService,
+    )(db)
 
     const sequencer = new Sequencer(modService(db))
 
@@ -183,6 +199,8 @@ export class AppContext {
         safelinkRuleService,
         scheduledActionService,
         teamService,
+        queueService,
+        reportStatsService,
         setService,
         settingService,
         strikeService,
@@ -195,6 +213,7 @@ export class AppContext {
         idResolver,
         backgroundQueue,
         sequencer,
+        assignmentService,
         authVerifier,
         blobDiverter,
         verificationService,
@@ -245,6 +264,14 @@ export class AppContext {
     return this.opts.teamService
   }
 
+  get queueService(): QueueServiceCreator {
+    return this.opts.queueService
+  }
+
+  get reportStatsService(): ReportStatsServiceCreator {
+    return this.opts.reportStatsService
+  }
+
   get setService(): SetServiceCreator {
     return this.opts.setService
   }
@@ -309,6 +336,10 @@ export class AppContext {
     return this.opts.sequencer
   }
 
+  get assignmentService(): AssignmentService {
+    return this.opts.assignmentService
+  }
+
   get authVerifier(): AuthVerifier {
     return this.opts.authVerifier
   }

package/src/daemon/context.ts

@@ -8,6 +8,8 @@ import { OzoneConfig, OzoneSecrets } from '../config'
 import { Database } from '../db'
 import { ModerationService } from '../mod-service'
 import { StrikeService } from '../mod-service/strike'
+import { QueueService } from '../queue/service'
+import { ReportStatsService } from '../report/stats'
 import { ScheduledActionService } from '../scheduled-action/service'
 import { SettingService } from '../setting/service'
 import { TeamService } from '../team'
@@ -15,7 +17,9 @@ import { getSigningKeyId } from '../util'
 import { EventPusher } from './event-pusher'
 import { EventReverser } from './event-reverser'
 import { MaterializedViewRefresher } from './materialized-view-refresher'
+import { QueueRouter } from './queue-router'
 import { ScheduledActionProcessor } from './scheduled-action-processor'
+import { StatsComputer } from './stats-computer'
 import { StrikeExpiryProcessor } from './strike-expiry-processor'
 import { TeamProfileSynchronizer } from './team-profile-synchronizer'
 import { VerificationListener } from './verification-listener'
@@ -31,7 +35,9 @@ export type DaemonContextOptions = {
   teamProfileSynchronizer: TeamProfileSynchronizer
   scheduledActionProcessor: ScheduledActionProcessor
   strikeExpiryProcessor: StrikeExpiryProcessor
+  queueRouter: QueueRouter
   verificationListener?: VerificationListener
+  statsComputer?: StatsComputer
 }
 
 export class DaemonContext {
@@ -111,6 +117,16 @@ export class DaemonContext {
 
     const strikeExpiryProcessor = new StrikeExpiryProcessor(db, strikeService)
 
+    const queueService = QueueService.creator()
+    const queueRouter = new QueueRouter(db, queueService)
+
+    const reportStatsService = ReportStatsService.creator()
+    const statsComputer = new StatsComputer(
+      db,
+      reportStatsService,
+      cfg.stats.computerIntervalMinutes,
+    )
+
     // Only spawn the listener if verifier config exists and a jetstream URL is provided
     const verificationListener =
       cfg.verifier && cfg.jetstreamUrl
@@ -132,7 +148,9 @@ export class DaemonContext {
       teamProfileSynchronizer,
       scheduledActionProcessor,
       strikeExpiryProcessor,
+      queueRouter,
       verificationListener,
+      statsComputer,
       ...(overrides ?? {}),
     })
   }
@@ -173,10 +191,18 @@ export class DaemonContext {
     return this.opts.strikeExpiryProcessor
   }
 
+  get queueRouter(): QueueRouter {
+    return this.opts.queueRouter
+  }
+
   get verificationListener(): VerificationListener | undefined {
     return this.opts.verificationListener
   }
 
+  get statsComputer(): StatsComputer | undefined {
+    return this.opts.statsComputer
+  }
+
   async start() {
     this.eventPusher.start()
     this.eventReverser.start()
@@ -184,12 +210,18 @@ export class DaemonContext {
     this.teamProfileSynchronizer.start()
     this.scheduledActionProcessor.start()
     this.strikeExpiryProcessor.start()
+    this.queueRouter.start()
     this.verificationListener?.start()
+    this.statsComputer?.start()
   }
 
   async processAll() {
     // Sequential because the materialized view values depend on the events.
     await this.eventPusher.processAll()
+    // Drain pending modEventReport rows into the report table so test code
+    // that calls processAll() after creating reports sees the report rows
+    // immediately (in production this happens via the 1-min poll).
+    await this.queueRouter.routeReports()
     await this.materializedViewRefresher.run()
     await this.teamProfileSynchronizer.run()
   }
@@ -203,7 +235,9 @@ export class DaemonContext {
         this.teamProfileSynchronizer.destroy(),
         this.scheduledActionProcessor.destroy(),
         this.strikeExpiryProcessor.destroy(),
+        this.queueRouter.destroy(),
         this.verificationListener?.stop(),
+        this.statsComputer?.destroy(),
       ])
     } finally {
       await this.backgroundQueue.destroy()

package/src/daemon/job-cursor.ts

@@ -0,0 +1,33 @@
+import { Database } from '../db'
+
+export async function initJobCursor(db: Database, job: string): Promise<void> {
+  await db.db
+    .insertInto('job_cursor')
+    .values({ job, cursor: null })
+    .onConflict((oc) => oc.doNothing())
+    .execute()
+}
+
+export async function getJobCursor(
+  db: Database,
+  job: string,
+): Promise<string | null> {
+  const entry = await db.db
+    .selectFrom('job_cursor')
+    .select('cursor')
+    .where('job', '=', job)
+    .executeTakeFirst()
+  return entry?.cursor ?? null
+}
+
+export async function updateJobCursor(
+  db: Database,
+  job: string,
+  cursor: string,
+): Promise<void> {
+  await db.db
+    .updateTable('job_cursor')
+    .set({ cursor })
+    .where('job', '=', job)
+    .execute()
+}

package/src/daemon/queue-router.ts

@@ -0,0 +1,101 @@
+import { MINUTE } from '@atproto/common'
+import { Database } from '../db'
+import { dbLogger } from '../logger'
+import { QueueServiceCreator } from '../queue/service'
+import { initJobCursor } from './job-cursor'
+
+const JOB_NAME = 'queue_router'
+const BATCH_SIZE = 100
+
+export class QueueRouter {
+  destroyed = false
+  processingPromise: Promise<void> = Promise.resolve()
+  timer?: NodeJS.Timeout
+
+  constructor(
+    private db: Database,
+    private queueServiceCreator: QueueServiceCreator,
+  ) {}
+
+  start() {
+    this.initializeCursor().then(() => this.poll())
+  }
+
+  poll() {
+    if (this.destroyed) return
+    this.processingPromise = this.routeReports()
+      .catch((err) => dbLogger.error({ err }, 'queue routing errored'))
+      .finally(() => {
+        this.timer = setTimeout(() => this.poll(), getInterval())
+      })
+  }
+
+  async destroy() {
+    this.destroyed = true
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    await this.processingPromise
+  }
+
+  async initializeCursor() {
+    await initJobCursor(this.db, JOB_NAME)
+  }
+
+  async getCursor(): Promise<number | null> {
+    const row = await this.db.db
+      .selectFrom('job_cursor')
+      .select('cursor')
+      .where('job', '=', JOB_NAME)
+      .executeTakeFirst()
+    return row?.cursor ? parseInt(row.cursor, 10) : null
+  }
+
+  async routeReports() {
+    await this.db.transaction(async (txn) => {
+      // Acquire row lock on the job_cursor row. A second daemon instance
+      // hitting this same query blocks here until the first transaction
+      // commits, then reads the now-advanced cursor and processes the next
+      // range. The lock is held for the whole batch (~50–200ms).
+      const row = await txn.db
+        .selectFrom('job_cursor')
+        .selectAll()
+        .where('job', '=', JOB_NAME)
+        .forUpdate()
+        .executeTakeFirst()
+      if (!row) return
+      const cursor = row.cursor ? parseInt(row.cursor, 10) : null
+
+      const queueService = this.queueServiceCreator(txn)
+      const result = await queueService.insertReportsFromEvents({
+        cursor,
+        limit: BATCH_SIZE,
+      })
+
+      if (result.processed === 0) {
+        dbLogger.info('no new report events to route')
+        return
+      }
+
+      await txn.db
+        .updateTable('job_cursor')
+        .set({ cursor: String(result.maxEventId) })
+        .where('job', '=', JOB_NAME)
+        .execute()
+
+      dbLogger.info(
+        {
+          processed: result.processed,
+          assigned: result.assigned,
+          unmatched: result.unmatched,
+          maxEventId: result.maxEventId,
+        },
+        'queue routing completed',
+      )
+    })
+  }
+}
+
+// Poll every 1 minute
+const getInterval = (): number => 1 * MINUTE

package/src/daemon/stats-computer.ts

@@ -0,0 +1,101 @@
+import { sql } from 'kysely'
+import { MINUTE } from '@atproto/common'
+import { Database } from '../db'
+import { dbLogger } from '../logger'
+import { ReportStatsServiceCreator } from '../report/stats'
+
+// Stable lock ID for pg_try_advisory_lock across all instances
+const ADVISORY_LOCK_ID = 7_239_401
+
+/**
+ * Background daemon that materializes report statistics on an interval (default is 15 minutes).
+ *
+ * Each cycle computes calendar-day snapshots: today's stats are recomputed (in-progress day),
+ * and yesterday's snapshot is finalized if it wasn't already. Historical snapshots (completed
+ * days) are write-once and never recomputed unless explicitly refreshed via the API.
+ *
+ * Query profile per cycle (assuming ~10K reports/day, 10 queues, 20 moderators, 9 type groups):
+ * - 7 batched GROUP BY queries against the report table for today's date window
+ *   (+ 7 more for yesterday if finalization is needed).
+ *   Day-window queries scan ~10K rows. Pending-count queries use partial indexes
+ *   (WHERE status != 'closed') so only scan open reports, not the full table.
+ *   Expected: ~10-50ms per query, ~100-350ms total report-table time.
+ * - ~40 lightweight reads against report_stat for freshness checks (small indexed table).
+ * - ~40 lightweight writes to report_stat for upserts.
+ *
+ * Locking: Uses pg_try_advisory_lock to ensure only one instance materializes at a time
+ * when running multiple containers. Advisory locks are cooperative, session-level locks —
+ * they do NOT block any table reads, writes, row locks, or transactions from other sessions.
+ * Normal application queries (report creation, moderation actions, API reads) are completely
+ * unaffected. If another instance already holds the lock, this instance skips the cycle
+ * immediately without blocking.
+ */
+export class StatsComputer {
+  destroyed = false
+  processingPromise: Promise<void> = Promise.resolve()
+  timer?: NodeJS.Timeout
+
+  constructor(
+    private db: Database,
+    private reportStatsServiceCreator: ReportStatsServiceCreator,
+    /**
+     * Minutes between stats computer cycles.
+     * Defaults to 15. Minimum is 1.
+     * Set to -1 to disable the stats computer.
+     */
+    private intervalMinutes: number,
+  ) {}
+
+  get disabled() {
+    return this.intervalMinutes < 1
+  }
+
+  start() {
+    this.poll()
+  }
+
+  poll() {
+    if (this.destroyed || this.disabled) return
+    this.processingPromise = this.materializeStats()
+      .catch((err) => dbLogger.error({ err }, 'stats materialization errored'))
+      .finally(() => {
+        this.timer = setTimeout(
+          () => this.poll(),
+          this.intervalMinutes * MINUTE,
+        )
+      })
+  }
+
+  private async materializeStats() {
+    const lockResult = await sql<{
+      locked: boolean
+    }>`SELECT pg_try_advisory_lock(${ADVISORY_LOCK_ID}) as locked`.execute(
+      this.db.db,
+    )
+    const acquired = lockResult.rows[0]?.locked === true
+    if (!acquired) {
+      dbLogger.info(
+        'stats materialization skipped, another instance holds lock',
+      )
+      return
+    }
+
+    try {
+      const statsService = this.reportStatsServiceCreator(this.db)
+      await statsService.materializeAll()
+    } finally {
+      await sql`SELECT pg_advisory_unlock(${ADVISORY_LOCK_ID})`.execute(
+        this.db.db,
+      )
+    }
+  }
+
+  async destroy() {
+    this.destroyed = true
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = undefined
+    }
+    await this.processingPromise
+  }
+}

package/src/daemon/strike-expiry-processor.ts

@@ -2,6 +2,7 @@ import { HOUR } from '@atproto/common'
 import { Database } from '../db'
 import { dbLogger } from '../logger'
 import { StrikeServiceCreator } from '../mod-service/strike'
+import { getJobCursor, initJobCursor, updateJobCursor } from './job-cursor'
 
 const JOB_NAME = 'strike_expiry'
 
@@ -40,32 +41,15 @@ export class StrikeExpiryProcessor {
   }
 
   async initializeCursor() {
-    await this.db.db
-      .insertInto('job_cursor')
-      .values({
-        job: JOB_NAME,
-        cursor: null,
-      })
-      .onConflict((oc) => oc.doNothing())
-      .execute()
+    await initJobCursor(this.db, JOB_NAME)
   }
 
   async getCursor(): Promise<string | null> {
-    const entry = await this.db.db
-      .selectFrom('job_cursor')
-      .select('cursor')
-      .where('job', '=', JOB_NAME)
-      .executeTakeFirst()
-
-    return entry?.cursor || null
+    return getJobCursor(this.db, JOB_NAME)
   }
 
   async updateCursor(cursor: string): Promise<void> {
-    await this.db.db
-      .updateTable('job_cursor')
-      .set({ cursor })
-      .where('job', '=', JOB_NAME)
-      .execute()
+    await updateJobCursor(this.db, JOB_NAME, cursor)
   }
 
   async processExpiredStrikes() {