@kaikybrofc/omnizap-system 2.2.4 → 2.2.6

package/app/modules/stickerPackModule/stickerStorageService.js

@@ -4,6 +4,7 @@ import { createHash, randomUUID } from 'node:crypto';
 
 import logger from '../../utils/logger/loggerModule.js';
 import { downloadMediaMessage, extractMediaDetails } from '../../config/baileysConfig.js';
+import { isFeatureEnabled } from '../../services/featureFlagService.js';
 import {
   createStickerAsset,
   findLatestStickerAssetByOwner,
@@ -14,6 +15,12 @@ import {
 import { ensureStickerAssetClassified } from './stickerClassificationService.js';
 import { STICKER_PACK_ERROR_CODES, StickerPackError } from './stickerPackErrors.js';
 import { normalizeOwnerJid } from './stickerPackUtils.js';
+import {
+  getStickerObjectStorageUrl,
+  isStickerObjectStorageEnabled,
+  readStickerFromObjectStorage,
+  uploadStickerToObjectStorage,
+} from './stickerObjectStorageService.js';
 
 /**
  * Camada de storage local para assets de figurinha do sistema de packs.
@@ -23,9 +30,29 @@ const TEMP_ROOT = path.join(process.cwd(), 'temp', 'sticker-pack-assets');
 const DEFAULT_MAX_STICKER_BYTES = 2 * 1024 * 1024;
 const MAX_STICKER_BYTES = Math.max(64 * 1024, Number(process.env.STICKER_PACK_MAX_STICKER_BYTES) || DEFAULT_MAX_STICKER_BYTES);
 const LAST_STICKER_TTL_MS = Math.max(60_000, Number(process.env.STICKER_PACK_LAST_CACHE_TTL_MS) || 6 * 60 * 60 * 1000);
+const OBJECT_STORAGE_UPLOAD_TIMEOUT_MS = Math.max(
+  1_000,
+  Number(process.env.STICKER_OBJECT_STORAGE_UPLOAD_TIMEOUT_MS) || 10_000,
+);
 
 const lastStickerCache = new Map();
 
+const withTimeout = (promise, ms) =>
+  Promise.race([
+    Promise.resolve(promise),
+    new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`timeout_after_${ms}ms`));
+      }, ms);
+    }),
+  ]);
+
+const isObjectStorageDeliveryEnabled = async (subjectKey = '') =>
+  isFeatureEnabled('enable_object_storage_delivery', {
+    fallback: false,
+    subjectKey: subjectKey || 'object_storage_delivery',
+  });
+
 /**
  * Converte JID para um token seguro no caminho de disco.
  *
@@ -182,6 +209,31 @@ const ensureStorageForAsset = async ({ ownerJid, sha256, buffer }) => {
   return targetPath;
 };
 
+const uploadExternalStorageBestEffort = async ({ ownerJid, sha256, buffer, mimetype = 'image/webp', assetId = null }) => {
+  if (!isStickerObjectStorageEnabled()) return;
+  const canUpload = await isObjectStorageDeliveryEnabled(normalizeOwnerJid(ownerJid) || sha256);
+  if (!canUpload) return;
+  try {
+    await withTimeout(
+      uploadStickerToObjectStorage({
+        ownerJid,
+        sha256,
+        buffer,
+        mimetype,
+      }),
+      OBJECT_STORAGE_UPLOAD_TIMEOUT_MS,
+    );
+  } catch (error) {
+    logger.warn('Falha no upload best-effort para object storage.', {
+      action: 'sticker_object_storage_upload_best_effort_failed',
+      owner_jid: ownerJid || null,
+      asset_id: assetId || null,
+      sha256: sha256 || null,
+      error: error?.message,
+    });
+  }
+};
+
 /**
  * Extrai detalhes de mídia sticker de uma mensagem.
  *
@@ -253,6 +305,13 @@ async function persistStickerAssetBuffer({ ownerJid, buffer, mimetype = 'image/w
           error: error?.message,
         });
       });
+      await uploadExternalStorageBestEffort({
+        ownerJid: normalizedOwner,
+        sha256,
+        buffer,
+        mimetype,
+        assetId: repaired.id,
+      });
       return repaired;
     }
 
@@ -265,6 +324,13 @@ async function persistStickerAssetBuffer({ ownerJid, buffer, mimetype = 'image/w
         error: error?.message,
       });
     });
+    await uploadExternalStorageBestEffort({
+      ownerJid: normalizedOwner,
+      sha256,
+      buffer,
+      mimetype,
+      assetId: existing.id,
+    });
     return existing;
   }
 
@@ -293,6 +359,13 @@ async function persistStickerAssetBuffer({ ownerJid, buffer, mimetype = 'image/w
         error: error?.message,
       });
     });
+    await uploadExternalStorageBestEffort({
+      ownerJid: normalizedOwner,
+      sha256,
+      buffer,
+      mimetype,
+      assetId: created.id,
+    });
     return created;
   } catch (error) {
     if (error?.code === 'ER_DUP_ENTRY') {
@@ -479,19 +552,46 @@ export async function resolveStickerAssetForCommand({
  * @throws {StickerPackError} Quando o arquivo não puder ser lido.
  */
 export async function readStickerAssetBuffer(asset) {
-  if (!asset?.storage_path) {
-    throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, 'Caminho do sticker não encontrado no storage.');
+  if (asset?.storage_path) {
+    try {
+      return await fs.readFile(asset.storage_path);
+    } catch (error) {
+      const externalBuffer = await readStickerFromObjectStorage(asset).catch(() => null);
+      if (Buffer.isBuffer(externalBuffer) && externalBuffer.length) {
+        return externalBuffer;
+      }
+      throw new StickerPackError(
+        STICKER_PACK_ERROR_CODES.STORAGE_ERROR,
+        `Não foi possível ler a figurinha em disco (${asset.storage_path}).`,
+        error,
+      );
+    }
   }
 
-  try {
-    return await fs.readFile(asset.storage_path);
-  } catch (error) {
-    throw new StickerPackError(
-      STICKER_PACK_ERROR_CODES.STORAGE_ERROR,
-      `Não foi possível ler a figurinha em disco (${asset.storage_path}).`,
-      error,
-    );
+  const externalBuffer = await readStickerFromObjectStorage(asset).catch(() => null);
+  if (Buffer.isBuffer(externalBuffer) && externalBuffer.length) {
+    return externalBuffer;
   }
+
+  throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, 'Caminho do sticker não encontrado no storage.');
+}
+
+export async function getStickerAssetExternalUrl(
+  asset,
+  {
+    secure = true,
+    expiresInSeconds = 300,
+  } = {},
+) {
+  if (!asset) return null;
+  const canUseExternalDelivery = await isObjectStorageDeliveryEnabled(
+    normalizeOwnerJid(asset?.owner_jid || '') || String(asset?.id || asset?.sha256 || ''),
+  );
+  if (!canUseExternalDelivery) return null;
+  return getStickerObjectStorageUrl(asset, {
+    secure,
+    expiresInSeconds,
+  });
 }
 
 /**
@@ -503,5 +603,6 @@ export function getStickerStorageConfig() {
   return {
     storageRoot: STORAGE_ROOT,
     maxStickerBytes: MAX_STICKER_BYTES,
+    objectStorageEnabled: isStickerObjectStorageEnabled(),
   };
 }

package/app/modules/stickerPackModule/stickerWorkerPipelineRuntime.js

@@ -1,5 +1,6 @@
 import logger from '../../utils/logger/loggerModule.js';
 import { setQueueDepth } from '../../observability/metrics.js';
+import { isFeatureEnabled } from '../../services/featureFlagService.js';
 import { runStickerClassificationCycle } from './stickerClassificationBackgroundRuntime.js';
 import { runStickerAutoPackByTagsCycle } from './stickerAutoPackByTagsRuntime.js';
 import {
@@ -24,6 +25,8 @@ const STARTUP_DELAY_MS = Math.max(1_000, Number(process.env.STICKER_WORKER_PIPEL
 const SCHEDULER_INTERVAL_MS = Math.max(2_000, Number(process.env.STICKER_WORKER_PIPELINE_SCHEDULER_INTERVAL_MS) || 15_000);
 const POLLER_INTERVAL_MS = Math.max(1_000, Number(process.env.STICKER_WORKER_PIPELINE_POLLER_INTERVAL_MS) || 4_000);
 const WORKER_RETRY_DELAY_SECONDS = Math.max(5, Math.min(3600, Number(process.env.STICKER_WORKER_PIPELINE_RETRY_DELAY_SECONDS) || 45));
+const INLINE_POLLER_ENABLED = parseEnvBool(process.env.STICKER_WORKER_PIPELINE_INLINE_POLLER_ENABLED, true);
+const INLINE_POLLER_FORCE_ENABLED = parseEnvBool(process.env.STICKER_WORKER_PIPELINE_INLINE_POLLER_FORCE_ENABLED, false);
 
 const TASK_CADENCE_MS = {
   classification_cycle: Math.max(10_000, Number(process.env.STICKER_WORKER_CLASSIFICATION_CADENCE_MS) || 120_000),
@@ -36,6 +39,10 @@ const TASK_PRIORITY = {
   curation_cycle: 55,
   rebuild_cycle: 50,
 };
+const PIPELINE_PROCESS_COHORT_KEY =
+  String(process.env.STICKER_WORKER_PIPELINE_COHORT_KEY || process.env.HOSTNAME || process.pid)
+    .trim()
+  || 'pipeline';
 
 let startupHandle = null;
 let schedulerHandle = null;
@@ -62,6 +69,16 @@ const refreshQueueDepthMetrics = async () => {
   setQueueDepth('sticker_worker_tasks_failed', failed);
 };
 
+const canRunInlinePoller = async () => {
+  if (!INLINE_POLLER_ENABLED) return false;
+  if (INLINE_POLLER_FORCE_ENABLED) return true;
+  const dedicatedWorkersEnabled = await isFeatureEnabled('enable_worker_dedicated_processes', {
+    fallback: false,
+    subjectKey: `pipeline:inline_poller:${PIPELINE_PROCESS_COHORT_KEY}`,
+  });
+  return !dedicatedWorkersEnabled;
+};
+
 const scheduleTaskIfNeeded = async (taskType) => {
   if (!taskQueueAvailable) return;
   const cadence = TASK_CADENCE_MS[taskType];
@@ -81,6 +98,7 @@ const scheduleTaskIfNeeded = async (taskType) => {
     taskType,
     payload: { scheduled_by: 'sticker_worker_pipeline' },
     priority: TASK_PRIORITY[taskType] || 50,
+    idempotencyKey: `pipeline:${taskType}:${Math.floor(now / cadence)}`,
   });
   nextScheduleByTask.set(taskType, now + cadence);
 };
@@ -150,6 +168,8 @@ const pollerTick = async () => {
   runningPoll = true;
 
   try {
+    if (!(await canRunInlinePoller())) return;
+
     let progressed = false;
 
     progressed = (await processSingleTaskType('classification_cycle')) || progressed;
@@ -191,6 +211,7 @@ export const startStickerWorkerPipeline = () => {
     startup_delay_ms: STARTUP_DELAY_MS,
     scheduler_interval_ms: SCHEDULER_INTERVAL_MS,
     poller_interval_ms: POLLER_INTERVAL_MS,
+    inline_poller_enabled: INLINE_POLLER_ENABLED,
     cadence_ms: TASK_CADENCE_MS,
   });
 

package/app/modules/stickerPackModule/stickerWorkerTaskQueueRepository.js

@@ -20,6 +20,19 @@ const clampInt = (value, fallback, min, max) => {
   return Math.max(min, Math.min(max, Math.floor(numeric)));
 };
 
+const CLAIM_LOCK_TIMEOUT_SECONDS = clampInt(
+  process.env.STICKER_WORKER_TASK_LOCK_TIMEOUT_SECONDS,
+  15 * 60,
+  30,
+  24 * 60 * 60,
+);
+
+const normalizeIdempotencyKey = (value) =>
+  String(value || '')
+    .trim()
+    .replace(/[^a-zA-Z0-9_:-]/g, '')
+    .slice(0, 180);
+
 const parseJson = (value, fallback = null) => {
   if (value === null || value === undefined) return fallback;
   if (typeof value === 'object') return value;
@@ -48,6 +61,7 @@ const normalizeRow = (row) => {
     id: Number(row.id),
     task_type: row.task_type,
     payload: parseJson(row.payload, {}),
+    idempotency_key: row.idempotency_key || null,
     priority: Number(row.priority || 0),
     scheduled_at: row.scheduled_at || null,
     status: row.status,
@@ -63,7 +77,7 @@ const normalizeRow = (row) => {
 };
 
 export async function enqueueWorkerTask(
-  { taskType, payload = {}, priority = 50, scheduledAt = null, maxAttempts = 5 },
+  { taskType, payload = {}, priority = 50, scheduledAt = null, maxAttempts = 5, idempotencyKey = '' },
   connection = null,
 ) {
   const normalizedTaskType = normalizeTaskType(taskType);
@@ -73,12 +87,26 @@ export async function enqueueWorkerTask(
   const safeMaxAttempts = clampInt(maxAttempts, 5, 1, 20);
   const safeScheduledAt = scheduledAt ? new Date(scheduledAt) : null;
   const scheduledValue = safeScheduledAt && Number.isFinite(safeScheduledAt.valueOf()) ? safeScheduledAt : null;
+  const normalizedIdempotencyKey = normalizeIdempotencyKey(idempotencyKey) || null;
 
   await executeQuery(
     `INSERT INTO ${TABLES.STICKER_WORKER_TASK_QUEUE}
-      (task_type, payload, priority, scheduled_at, status, attempts, max_attempts)
-     VALUES (?, ?, ?, COALESCE(?, UTC_TIMESTAMP()), 'pending', 0, ?)`,
-    [normalizedTaskType, JSON.stringify(payload || {}), safePriority, scheduledValue, safeMaxAttempts],
+      (task_type, idempotency_key, payload, priority, scheduled_at, status, attempts, max_attempts)
+     VALUES (?, ?, ?, ?, COALESCE(?, UTC_TIMESTAMP()), 'pending', 0, ?)
+     ON DUPLICATE KEY UPDATE
+      payload = IF(status IN ('pending', 'failed'), VALUES(payload), payload),
+      priority = GREATEST(priority, VALUES(priority)),
+      scheduled_at = LEAST(scheduled_at, VALUES(scheduled_at)),
+      status = IF(status = 'failed' AND attempts < max_attempts, 'pending', status),
+      updated_at = UTC_TIMESTAMP()`,
+    [
+      normalizedTaskType,
+      normalizedIdempotencyKey,
+      JSON.stringify(payload || {}),
+      safePriority,
+      scheduledValue,
+      safeMaxAttempts,
+    ],
     connection,
   );
   return true;
@@ -92,7 +120,10 @@ export async function hasPendingWorkerTask(taskType, connection = null) {
     `SELECT id
      FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
      WHERE task_type = ?
-       AND status IN ('pending', 'processing')
+       AND (
+         status IN ('pending', 'processing')
+         OR (status = 'failed' AND attempts < max_attempts)
+       )
      LIMIT 1`,
     [normalizedTaskType],
     connection,
@@ -106,8 +137,11 @@ export async function claimWorkerTask({ taskType, allowRetryFailed = true } = {}
 
   const workerToken = randomUUID();
   const statusClause = allowRetryFailed
-    ? "(status = 'pending' OR (status = 'failed' AND attempts < max_attempts))"
-    : "status = 'pending'";
+    ? `(status = 'pending'
+      OR (status = 'failed' AND attempts < max_attempts)
+      OR (status = 'processing' AND locked_at <= (UTC_TIMESTAMP() - INTERVAL ${CLAIM_LOCK_TIMEOUT_SECONDS} SECOND)))`
+    : `(status = 'pending'
+      OR (status = 'processing' AND locked_at <= (UTC_TIMESTAMP() - INTERVAL ${CLAIM_LOCK_TIMEOUT_SECONDS} SECOND)))`;
 
   await executeQuery(
     `UPDATE ${TABLES.STICKER_WORKER_TASK_QUEUE}
@@ -187,6 +221,24 @@ export async function failWorkerTask(
     [message, taskId],
     connection,
   );
+
+  await executeQuery(
+    `INSERT INTO ${TABLES.STICKER_WORKER_TASK_DLQ}
+      (task_id, task_type, payload, idempotency_key, attempts, max_attempts, priority, last_error)
+     SELECT id, task_type, payload, idempotency_key, attempts, max_attempts, priority, last_error
+       FROM ${TABLES.STICKER_WORKER_TASK_QUEUE}
+      WHERE id = ?
+        AND status = 'failed'
+     ON DUPLICATE KEY UPDATE
+      attempts = VALUES(attempts),
+      max_attempts = VALUES(max_attempts),
+      priority = VALUES(priority),
+      last_error = VALUES(last_error),
+      failed_at = CURRENT_TIMESTAMP`,
+    [taskId],
+    connection,
+  ).catch(() => null);
+
   return true;
 }
 

package/app/observability/metrics.js

@@ -1,6 +1,7 @@
 import 'dotenv/config';
 
 import http from 'node:http';
+import { randomUUID } from 'node:crypto';
 import { URL } from 'node:url';
 import client from 'prom-client';
 import logger from '../utils/logger/loggerModule.js';
@@ -32,6 +33,7 @@ const METRICS_PORT = parseEnvNumber(process.env.METRICS_PORT, 9102);
 const METRICS_HOST = process.env.METRICS_HOST || '0.0.0.0';
 const METRICS_PATH = process.env.METRICS_PATH || '/metrics';
 const METRICS_SERVICE = process.env.METRICS_SERVICE_NAME || process.env.ECOSYSTEM_NAME || 'omnizap';
+const HTTP_SLO_TARGET_MS = Math.max(50, parseEnvNumber(process.env.HTTP_SLO_TARGET_MS, 750));
 
 const QUERY_THRESHOLDS_MS = parseThresholds(process.env.DB_QUERY_ALERT_THRESHOLDS, [500, 1000]);
 
@@ -46,6 +48,55 @@ const normalizeLabel = (value, fallback = 'unknown') => {
   return String(value);
 };
 
+const normalizeRequestId = (value) => {
+  const token = String(value || '')
+    .trim()
+    .replace(/[^a-zA-Z0-9._:-]/g, '')
+    .slice(0, 120);
+  return token || randomUUID();
+};
+
+const normalizeHttpMethod = (method) => {
+  const normalized = String(method || '').trim().toUpperCase();
+  if (!normalized) return 'UNKNOWN';
+  if (normalized.length > 12) return normalized.slice(0, 12);
+  return normalized;
+};
+
+const toStatusClass = (statusCode) => {
+  const numeric = Number(statusCode);
+  if (!Number.isFinite(numeric) || numeric < 100) return 'unknown';
+  const head = Math.floor(numeric / 100);
+  return `${head}xx`;
+};
+
+const resolveRouteGroup = ({ pathname, metricsPath, catalogConfig = null } = {}) => {
+  if (pathname?.startsWith(metricsPath)) return 'metrics';
+  if (pathname === '/sitemap.xml') return 'sitemap';
+  if (pathname === '/api/marketplace/stats') return 'marketplace_stats';
+
+  const apiBasePath = catalogConfig?.apiBasePath || '';
+  const webPath = catalogConfig?.webPath || '';
+  const dataPublicPath = catalogConfig?.dataPublicPath || '';
+  const userProfilePath = catalogConfig?.userProfilePath || '';
+
+  if (apiBasePath && (pathname === apiBasePath || pathname?.startsWith(`${apiBasePath}/`))) {
+    if (pathname === `${apiBasePath}/auth/google/session` || pathname === `${apiBasePath}/me` || pathname === `${apiBasePath}/admin/session`) {
+      return 'catalog_api_auth';
+    }
+    if (pathname === `${apiBasePath}/create` || /\/(manage|finalize|stickers-upload|publish-state)(\/|$)/.test(pathname || '')) {
+      return 'catalog_api_upload';
+    }
+    if (pathname?.startsWith(`${apiBasePath}/admin`)) return 'catalog_api_admin';
+    return 'catalog_api_public';
+  }
+  if (dataPublicPath && (pathname === dataPublicPath || pathname?.startsWith(`${dataPublicPath}/`))) return 'catalog_data_asset';
+  if (userProfilePath && (pathname === userProfilePath || pathname === `${userProfilePath}/`)) return 'catalog_user_profile';
+  if (webPath && (pathname === webPath || pathname?.startsWith(`${webPath}/`))) return 'catalog_web';
+
+  return 'other';
+};
+
 const ensureMetrics = () => {
   if (!METRICS_ENABLED) return null;
   if (metrics) return metrics;
@@ -108,6 +159,25 @@ const ensureMetrics = () => {
       labelNames: ['queue'],
       registers: [registry],
     }),
+    httpRequestsTotal: new client.Counter({
+      name: 'omnizap_http_requests_total',
+      help: 'Total de requests HTTP por rota lógica',
+      labelNames: ['route_group', 'method', 'status_class'],
+      registers: [registry],
+    }),
+    httpRequestDurationMs: new client.Histogram({
+      name: 'omnizap_http_request_duration_ms',
+      help: 'Latência de requests HTTP em ms por rota lógica',
+      buckets: [5, 10, 20, 40, 75, 120, 200, 350, 500, 750, 1000, 2000, 5000, 10000],
+      labelNames: ['route_group', 'method', 'status_class'],
+      registers: [registry],
+    }),
+    httpSloViolationTotal: new client.Counter({
+      name: 'omnizap_http_slo_violation_total',
+      help: 'Total de requests HTTP acima do SLO de latência',
+      labelNames: ['route_group', 'method'],
+      registers: [registry],
+    }),
     messagesUpsertDurationMs: new client.Histogram({
       name: 'omnizap_messages_upsert_duration_ms',
       help: 'Duracao de processamento de messages.upsert em ms',
@@ -296,6 +366,25 @@ const ensureMetrics = () => {
       help: 'Taxa de packs completos em relacao ao target_size (0-1)',
       registers: [registry],
     }),
+    stickerClassificationCycleDurationMs: new client.Histogram({
+      name: 'omnizap_sticker_classification_cycle_duration_ms',
+      help: 'Duração do ciclo de classificação de sticker em ms',
+      buckets: [50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000, 60000],
+      labelNames: ['status'],
+      registers: [registry],
+    }),
+    stickerClassificationCycleTotal: new client.Counter({
+      name: 'omnizap_sticker_classification_cycle_total',
+      help: 'Total de ciclos de classificação de sticker',
+      labelNames: ['status'],
+      registers: [registry],
+    }),
+    stickerClassificationAssetsTotal: new client.Counter({
+      name: 'omnizap_sticker_classification_assets_total',
+      help: 'Total de assets processados/classificados/falhos por ciclo',
+      labelNames: ['outcome'],
+      registers: [registry],
+    }),
   };
 
   return metrics;
@@ -314,6 +403,10 @@ export const startMetricsServer = () => {
   if (!METRICS_ENABLED || serverStarted) return;
   ensureMetrics();
   server = http.createServer(async (req, res) => {
+    const requestStartedAt = Date.now();
+    const requestId = normalizeRequestId(req.headers['x-request-id']);
+    res.setHeader('X-Request-Id', requestId);
+
     const host = req.headers.host || `${METRICS_HOST}:${METRICS_PORT}`;
     let parsedUrl;
     try {
@@ -322,9 +415,32 @@ export const startMetricsServer = () => {
       parsedUrl = new URL(req.url || '/', 'http://localhost');
     }
     const pathname = parsedUrl.pathname;
+    let routeGroup = resolveRouteGroup({
+      pathname,
+      metricsPath: METRICS_PATH,
+      catalogConfig: null,
+    });
+
+    res.once('finish', () => {
+      recordHttpRequest({
+        durationMs: Date.now() - requestStartedAt,
+        method: req.method,
+        statusCode: res.statusCode,
+        routeGroup,
+      });
+    });
 
     try {
       const stickerCatalogModule = await loadStickerCatalogModule();
+      const catalogConfig =
+        typeof stickerCatalogModule.getStickerCatalogConfig === 'function'
+          ? stickerCatalogModule.getStickerCatalogConfig()
+          : null;
+      routeGroup = resolveRouteGroup({
+        pathname,
+        metricsPath: METRICS_PATH,
+        catalogConfig,
+      });
       const handledByCatalog = await stickerCatalogModule.maybeHandleStickerCatalogRequest(req, res, {
         pathname,
         url: parsedUrl,
@@ -422,6 +538,28 @@ export const setQueueDepth = (queue, depth) => {
   m.queueDepth.set({ queue: normalizeLabel(queue, 'unknown') }, value);
 };
 
+export const recordHttpRequest = ({ durationMs, method, statusCode, routeGroup }) => {
+  const m = ensureMetrics();
+  if (!m) return;
+  const duration = Number(durationMs);
+  if (!Number.isFinite(duration) || duration < 0) return;
+
+  const labels = {
+    route_group: normalizeLabel(routeGroup, 'other'),
+    method: normalizeHttpMethod(method),
+    status_class: toStatusClass(statusCode),
+  };
+
+  m.httpRequestsTotal.inc(labels);
+  m.httpRequestDurationMs.observe(labels, duration);
+  if (duration >= HTTP_SLO_TARGET_MS) {
+    m.httpSloViolationTotal.inc({
+      route_group: labels.route_group,
+      method: labels.method,
+    });
+  }
+};
+
 export const setDbInFlight = (value) => {
   const m = ensureMetrics();
   if (!m) return;
@@ -732,3 +870,34 @@ export const recordStickerAutoPackCycle = ({
     m.stickerAutoPackFillRate.set(Math.max(0, Math.min(1, fill)));
   }
 };
+
+export const recordStickerClassificationCycle = ({
+  status = 'ok',
+  durationMs,
+  processed = 0,
+  classified = 0,
+  failed = 0,
+} = {}) => {
+  const m = ensureMetrics();
+  if (!m) return;
+
+  const cycleStatus = normalizeLabel(status, 'ok').slice(0, 24);
+  const duration = Number(durationMs);
+  if (Number.isFinite(duration) && duration >= 0) {
+    m.stickerClassificationCycleDurationMs.observe({ status: cycleStatus }, duration);
+  }
+  m.stickerClassificationCycleTotal.inc({ status: cycleStatus });
+
+  const processedValue = Number(processed);
+  if (Number.isFinite(processedValue) && processedValue > 0) {
+    m.stickerClassificationAssetsTotal.inc({ outcome: 'processed' }, processedValue);
+  }
+  const classifiedValue = Number(classified);
+  if (Number.isFinite(classifiedValue) && classifiedValue > 0) {
+    m.stickerClassificationAssetsTotal.inc({ outcome: 'classified' }, classifiedValue);
+  }
+  const failedValue = Number(failed);
+  if (Number.isFinite(failedValue) && failedValue > 0) {
+    m.stickerClassificationAssetsTotal.inc({ outcome: 'failed' }, failedValue);
+  }
+};