@kaikybrofc/omnizap-system 2.2.3 → 2.2.5

package/app/modules/stickerPackModule/stickerDedicatedTaskWorkerRuntime.js

@@ -0,0 +1,238 @@
+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 {
+  claimWorkerTask,
+  completeWorkerTask,
+  countWorkerTasksByStatus,
+  failWorkerTask,
+} from './stickerWorkerTaskQueueRepository.js';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const clampInt = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(numeric)));
+};
+
+const DEDICATED_WORKERS_ENABLED = parseEnvBool(process.env.STICKER_DEDICATED_WORKERS_ENABLED, true);
+const DEDICATED_WORKERS_FORCE_ENABLED = parseEnvBool(process.env.STICKER_DEDICATED_WORKERS_FORCE_ENABLED, false);
+const DEDICATED_WORKER_RETRY_DELAY_SECONDS = clampInt(
+  process.env.STICKER_DEDICATED_WORKER_RETRY_DELAY_SECONDS,
+  60,
+  5,
+  3600,
+);
+const DEDICATED_WORKER_POLL_INTERVAL_MS = clampInt(
+  process.env.STICKER_DEDICATED_WORKER_POLL_INTERVAL_MS,
+  2500,
+  250,
+  60_000,
+);
+const DEDICATED_WORKER_MAX_TASKS_PER_TICK = clampInt(
+  process.env.STICKER_DEDICATED_WORKER_MAX_TASKS_PER_TICK,
+  1,
+  1,
+  25,
+);
+const DEDICATED_WORKER_COHORT_KEY =
+  String(process.env.STICKER_DEDICATED_WORKER_COHORT_KEY || process.env.HOSTNAME || process.pid).trim()
+  || 'worker';
+
+const SUPPORTED_TASK_TYPES = new Set([
+  'classification_cycle',
+  'curation_cycle',
+  'rebuild_cycle',
+]);
+
+const normalizeTaskType = (value) => {
+  const normalized = String(value || '').trim().toLowerCase();
+  return SUPPORTED_TASK_TYPES.has(normalized) ? normalized : null;
+};
+
+const runTaskHandler = async (taskType, payload = {}) => {
+  if (taskType === 'classification_cycle') {
+    return runStickerClassificationCycle({
+      processPending: true,
+      processReprocess: true,
+      processDeterministic: true,
+      ...payload,
+    });
+  }
+  if (taskType === 'curation_cycle') {
+    return runStickerAutoPackByTagsCycle({
+      enableAdditions: true,
+      enableRebuild: false,
+      ...payload,
+    });
+  }
+  if (taskType === 'rebuild_cycle') {
+    return runStickerAutoPackByTagsCycle({
+      enableAdditions: false,
+      enableRebuild: true,
+      ...payload,
+    });
+  }
+  throw new Error(`unsupported_task_type:${taskType}`);
+};
+
+const refreshQueueDepthMetrics = async () => {
+  const [pending, processing, failed] = await Promise.all([
+    countWorkerTasksByStatus('pending'),
+    countWorkerTasksByStatus('processing'),
+    countWorkerTasksByStatus('failed'),
+  ]);
+  setQueueDepth('sticker_worker_tasks_pending', pending);
+  setQueueDepth('sticker_worker_tasks_processing', processing);
+  setQueueDepth('sticker_worker_tasks_failed', failed);
+};
+
+const canRunDedicatedWorkers = async (taskType) => {
+  if (!DEDICATED_WORKERS_ENABLED) return false;
+  if (DEDICATED_WORKERS_FORCE_ENABLED) return true;
+  return isFeatureEnabled('enable_worker_dedicated_processes', {
+    fallback: false,
+    subjectKey: `worker:${taskType}:${DEDICATED_WORKER_COHORT_KEY}`,
+  });
+};
+
+export const isSupportedStickerWorkerTaskType = (taskType) => Boolean(normalizeTaskType(taskType));
+
+export const runDedicatedStickerWorkerTick = async (
+  {
+    taskType,
+    maxTasks = DEDICATED_WORKER_MAX_TASKS_PER_TICK,
+    retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS,
+  } = {},
+) => {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) {
+    return { executed: false, reason: 'invalid_task_type', task_type: taskType || null };
+  }
+
+  const enabled = await canRunDedicatedWorkers(normalizedTaskType);
+  if (!enabled) {
+    return { executed: false, reason: 'feature_disabled', task_type: normalizedTaskType };
+  }
+
+  const safeMaxTasks = clampInt(maxTasks, DEDICATED_WORKER_MAX_TASKS_PER_TICK, 1, 25);
+  const stats = {
+    executed: true,
+    task_type: normalizedTaskType,
+    claimed: 0,
+    completed: 0,
+    failed: 0,
+  };
+
+  for (let i = 0; i < safeMaxTasks; i += 1) {
+    const task = await claimWorkerTask({ taskType: normalizedTaskType });
+    if (!task) break;
+
+    stats.claimed += 1;
+
+    try {
+      await runTaskHandler(normalizedTaskType, task.payload || {});
+      await completeWorkerTask(task.id);
+      stats.completed += 1;
+    } catch (error) {
+      stats.failed += 1;
+      await failWorkerTask(task.id, {
+        error: error?.message || 'dedicated_worker_task_failed',
+        retryDelaySeconds,
+      });
+
+      logger.warn('Task falhou no worker dedicado.', {
+        action: 'sticker_dedicated_worker_task_failed',
+        task_type: normalizedTaskType,
+        task_id: task.id,
+        attempts: task.attempts,
+        error: error?.message,
+      });
+    }
+  }
+
+  if (stats.claimed > 0) {
+    await refreshQueueDepthMetrics().catch(() => null);
+  }
+
+  return stats;
+};
+
+export const startDedicatedStickerWorker = ({
+  taskType,
+  pollIntervalMs = DEDICATED_WORKER_POLL_INTERVAL_MS,
+  maxTasksPerTick = DEDICATED_WORKER_MAX_TASKS_PER_TICK,
+  retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS,
+  label = '',
+} = {}) => {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) {
+    throw new Error(`invalid_task_type:${taskType}`);
+  }
+
+  const safePollIntervalMs = clampInt(pollIntervalMs, DEDICATED_WORKER_POLL_INTERVAL_MS, 250, 60_000);
+  let tickInFlight = false;
+  let stopped = false;
+
+  const runTick = async () => {
+    if (stopped || tickInFlight) return;
+    tickInFlight = true;
+    try {
+      await runDedicatedStickerWorkerTick({
+        taskType: normalizedTaskType,
+        maxTasks: maxTasksPerTick,
+        retryDelaySeconds,
+      });
+    } catch (error) {
+      if (error?.code !== 'ER_NO_SUCH_TABLE') {
+        logger.error('Falha no worker dedicado de sticker.', {
+          action: 'sticker_dedicated_worker_tick_failed',
+          task_type: normalizedTaskType,
+          error: error?.message,
+        });
+      }
+    } finally {
+      tickInFlight = false;
+    }
+  };
+
+  const intervalHandle = setInterval(() => {
+    void runTick();
+  }, safePollIntervalMs);
+  if (typeof intervalHandle?.unref === 'function') {
+    intervalHandle.unref();
+  }
+
+  void runTick();
+
+  logger.info('Worker dedicado de sticker iniciado.', {
+    action: 'sticker_dedicated_worker_started',
+    task_type: normalizedTaskType,
+    poll_interval_ms: safePollIntervalMs,
+    max_tasks_per_tick: maxTasksPerTick,
+    label: label || null,
+  });
+
+  return {
+    taskType: normalizedTaskType,
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(intervalHandle);
+      logger.info('Worker dedicado de sticker encerrado.', {
+        action: 'sticker_dedicated_worker_stopped',
+        task_type: normalizedTaskType,
+        label: label || null,
+      });
+    },
+  };
+};

package/app/modules/stickerPackModule/stickerDomainEventBus.js

@@ -0,0 +1,71 @@
+import logger from '../../utils/logger/loggerModule.js';
+import { isFeatureEnabled } from '../../services/featureFlagService.js';
+import { enqueueDomainEvent } from './domainEventOutboxRepository.js';
+
+const resolveDefaultIdempotencyKey = ({
+  eventType,
+  aggregateType,
+  aggregateId,
+  payload = null,
+}) => {
+  const payloadKey = payload && typeof payload === 'object' ? JSON.stringify(payload).slice(0, 80) : '';
+  return `${eventType}:${aggregateType}:${aggregateId}:${payloadKey}`.slice(0, 180);
+};
+
+export const publishStickerDomainEvent = async (
+  eventPayload,
+  { connection = null, force = false } = {},
+) => {
+  const eventType = String(eventPayload?.eventType || '').trim();
+  const aggregateType = String(eventPayload?.aggregateType || '').trim();
+  const aggregateId = String(eventPayload?.aggregateId || '').trim();
+
+  if (!eventType || !aggregateType || !aggregateId) return false;
+
+  const enabled = force ? true : await isFeatureEnabled('enable_domain_event_outbox', {
+    fallback: true,
+    subjectKey: `${aggregateType}:${aggregateId}`,
+  });
+  if (!enabled) return false;
+
+  try {
+    const idempotencyKey =
+      String(eventPayload?.idempotencyKey || '').trim()
+      || resolveDefaultIdempotencyKey({
+        eventType,
+        aggregateType,
+        aggregateId,
+        payload: eventPayload?.payload || null,
+      });
+
+    return await enqueueDomainEvent(
+      {
+        eventType,
+        aggregateType,
+        aggregateId,
+        payload: eventPayload?.payload || null,
+        priority: eventPayload?.priority ?? 50,
+        availableAt: eventPayload?.availableAt || null,
+        maxAttempts: eventPayload?.maxAttempts ?? 10,
+        idempotencyKey,
+      },
+      connection,
+    );
+  } catch (error) {
+    if (error?.code === 'ER_NO_SUCH_TABLE') {
+      logger.warn('Outbox indisponível; evento de domínio descartado.', {
+        action: 'sticker_domain_event_outbox_unavailable',
+        event_type: eventType,
+      });
+      return false;
+    }
+    logger.warn('Falha ao publicar evento de domínio.', {
+      action: 'sticker_domain_event_publish_failed',
+      event_type: eventType,
+      aggregate_type: aggregateType,
+      aggregate_id: aggregateId,
+      error: error?.message,
+    });
+    return false;
+  }
+};

package/app/modules/stickerPackModule/stickerDomainEventConsumerRuntime.js

@@ -0,0 +1,198 @@
+import logger from '../../utils/logger/loggerModule.js';
+import { setQueueDepth } from '../../observability/metrics.js';
+import { isFeatureEnabled } from '../../services/featureFlagService.js';
+import {
+  claimDomainEvent,
+  completeDomainEvent,
+  countDomainEventsByStatus,
+  failDomainEvent,
+} from './domainEventOutboxRepository.js';
+import { STICKER_DOMAIN_EVENTS } from './domainEvents.js';
+import { enqueueWorkerTask } from './stickerWorkerTaskQueueRepository.js';
+import { enqueuePackScoreSnapshotRefresh } from './stickerPackScoreSnapshotRuntime.js';
+import { listPackIdsByStickerId } from './stickerPackItemRepository.js';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const CONSUMER_ENABLED = parseEnvBool(process.env.STICKER_DOMAIN_EVENT_CONSUMER_ENABLED, true);
+const STARTUP_DELAY_MS = Math.max(
+  1_000,
+  Number(process.env.STICKER_DOMAIN_EVENT_CONSUMER_STARTUP_DELAY_MS) || 8_000,
+);
+const POLLER_INTERVAL_MS = Math.max(
+  1_000,
+  Number(process.env.STICKER_DOMAIN_EVENT_CONSUMER_POLLER_INTERVAL_MS) || 2_000,
+);
+const RETRY_DELAY_SECONDS = Math.max(
+  5,
+  Math.min(3600, Number(process.env.STICKER_DOMAIN_EVENT_CONSUMER_RETRY_DELAY_SECONDS) || 45),
+);
+const CONSUMER_COHORT_KEY =
+  String(process.env.STICKER_DOMAIN_EVENT_CONSUMER_COHORT_KEY || process.env.HOSTNAME || process.pid).trim()
+  || 'consumer';
+
+let startupHandle = null;
+let pollerHandle = null;
+let running = false;
+
+const refreshOutboxDepthMetrics = async () => {
+  const [pending, processing, failed] = await Promise.all([
+    countDomainEventsByStatus('pending'),
+    countDomainEventsByStatus('processing'),
+    countDomainEventsByStatus('failed'),
+  ]);
+  setQueueDepth('domain_event_outbox_pending', pending);
+  setQueueDepth('domain_event_outbox_processing', processing);
+  setQueueDepth('domain_event_outbox_failed', failed);
+};
+
+const canRunConsumer = async () =>
+  isFeatureEnabled('enable_domain_event_outbox', {
+    fallback: true,
+    subjectKey: `domain_event_consumer:${CONSUMER_COHORT_KEY}`,
+  });
+
+const enqueueTaskSafely = async ({ taskType, payload, priority, idempotencyKey }) => {
+  await enqueueWorkerTask({
+    taskType,
+    payload,
+    priority,
+    idempotencyKey,
+  });
+};
+
+const handleDomainEvent = async (event) => {
+  const eventType = String(event?.event_type || '').trim().toUpperCase();
+  const aggregateId = String(event?.aggregate_id || '').trim();
+  const payload = event?.payload && typeof event.payload === 'object' ? event.payload : {};
+
+  if (eventType === STICKER_DOMAIN_EVENTS.STICKER_ASSET_CREATED) {
+    await enqueueTaskSafely({
+      taskType: 'classification_cycle',
+      payload: { reason: 'domain_event', event_type: eventType, aggregate_id: aggregateId },
+      priority: 80,
+      idempotencyKey: `evt:${event.id}:classification_cycle`,
+    });
+    return;
+  }
+
+  if (eventType === STICKER_DOMAIN_EVENTS.STICKER_CLASSIFIED) {
+    const assetId = String(payload?.asset_id || aggregateId || '').trim();
+    const relatedPackIds = assetId ? await listPackIdsByStickerId(assetId).catch(() => []) : [];
+    if (relatedPackIds.length) {
+      enqueuePackScoreSnapshotRefresh(relatedPackIds);
+    }
+    await enqueueTaskSafely({
+      taskType: 'curation_cycle',
+      payload: {
+        reason: 'domain_event',
+        event_type: eventType,
+        aggregate_id: aggregateId,
+        related_pack_ids: relatedPackIds,
+      },
+      priority: 65,
+      idempotencyKey: `evt:${event.id}:curation_cycle`,
+    });
+    return;
+  }
+
+  if (eventType === STICKER_DOMAIN_EVENTS.PACK_UPDATED) {
+    const packId = String(payload?.pack_id || aggregateId || '').trim();
+    if (packId) {
+      enqueuePackScoreSnapshotRefresh([packId]);
+    }
+    await enqueueTaskSafely({
+      taskType: 'rebuild_cycle',
+      payload: { reason: 'domain_event', event_type: eventType, aggregate_id: aggregateId, pack_id: packId || null },
+      priority: 60,
+      idempotencyKey: `evt:${event.id}:rebuild_cycle`,
+    });
+    return;
+  }
+
+  if (eventType === STICKER_DOMAIN_EVENTS.ENGAGEMENT_RECORDED) {
+    const packId = String(payload?.pack_id || aggregateId || '').trim();
+    if (packId) {
+      enqueuePackScoreSnapshotRefresh([packId]);
+    }
+    return;
+  }
+};
+
+const pollOnce = async () => {
+  if (running || !CONSUMER_ENABLED) return;
+  running = true;
+  try {
+    if (!(await canRunConsumer())) return;
+
+    const event = await claimDomainEvent();
+    if (!event) {
+      await refreshOutboxDepthMetrics();
+      return;
+    }
+
+    try {
+      await handleDomainEvent(event);
+      await completeDomainEvent(event.id);
+    } catch (error) {
+      await failDomainEvent(
+        event.id,
+        {
+          error: error?.message || 'domain_event_consumer_failed',
+          retryDelaySeconds: RETRY_DELAY_SECONDS,
+        },
+      );
+      logger.warn('Evento de domínio falhou no consumidor interno.', {
+        action: 'sticker_domain_event_consumer_event_failed',
+        event_id: event.id,
+        event_type: event.event_type,
+        aggregate_type: event.aggregate_type,
+        aggregate_id: event.aggregate_id,
+        error: error?.message,
+      });
+    }
+
+    await refreshOutboxDepthMetrics();
+  } catch (error) {
+    if (error?.code !== 'ER_NO_SUCH_TABLE') {
+      logger.error('Falha no poller do consumidor de eventos de domínio.', {
+        action: 'sticker_domain_event_consumer_poll_failed',
+        error: error?.message,
+      });
+    }
+  } finally {
+    running = false;
+  }
+};
+
+export const startStickerDomainEventConsumer = () => {
+  if (!CONSUMER_ENABLED) return;
+  if (startupHandle || pollerHandle) return;
+
+  startupHandle = setTimeout(() => {
+    startupHandle = null;
+    void pollOnce();
+    pollerHandle = setInterval(() => {
+      void pollOnce();
+    }, POLLER_INTERVAL_MS);
+    if (typeof pollerHandle?.unref === 'function') pollerHandle.unref();
+  }, STARTUP_DELAY_MS);
+  if (typeof startupHandle?.unref === 'function') startupHandle.unref();
+};
+
+export const stopStickerDomainEventConsumer = () => {
+  if (startupHandle) {
+    clearTimeout(startupHandle);
+    startupHandle = null;
+  }
+  if (pollerHandle) {
+    clearInterval(pollerHandle);
+    pollerHandle = null;
+  }
+};