cdp-edge 2.0.4 → 2.0.5

package/server-edge-tracker/worker.js

@@ -70,8 +70,226 @@ function corsHeaders(origin, siteDomain) {
   };
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// LOGISTIC REGRESSION — LTV Model (pure JS, sem deps externas)
+// ─────────────────────────────────────────────────────────────────────────────
+
+const _UTM_SCORES = {
+  facebook: 0.90, instagram: 0.90, meta: 0.90,
+  google: 0.82, youtube: 0.82, tiktok: 0.75,
+  email: 0.68, sms: 0.68, organic: 0.30, direct: 0.20,
+};
+const _INTENTION_SCORES = {
+  comprador: 1.00, high_intent: 1.00, interessado: 0.60, nurture: 0.30, curioso: 0.15,
+};
+
+function _extractFeatures(row) {
+  const src       = (row.utm_source || '').toLowerCase().trim();
+  const intention = (row.intention_level || '').toLowerCase().trim();
+  const daysSince = row.days_since_lead || 0;
+  return [
+    _UTM_SCORES[src] ?? (src ? 0.10 : 0.05),
+    Math.min((row.engagement_score || 0) / 5, 1),
+    _INTENTION_SCORES[intention] ?? 0,
+    Math.max(0, 1 - daysSince / 90),
+    row.has_email  ? 1 : 0,
+    row.has_phone  ? 1 : 0,
+    row.is_br      ? 1 : 0,
+    ((row.hour || 12) / 23),
+  ];
+}
+
+function _sigmoid(z) {
+  if (z > 20) return 1;
+  if (z < -20) return 0;
+  return 1 / (1 + Math.exp(-z));
+}
+
+function _dot(weights, features) {
+  return features.reduce((sum, f, i) => sum + (weights[i] || 0) * f, 0);
+}
+
+function _trainLogisticRegression(dataset, opts = {}) {
+  if (!dataset || dataset.length < 50) return null;
+  const iterations   = opts.iterations   || 200;
+  const learningRate = opts.learningRate  || 0.1;
+  const lambda       = opts.lambda        || 0.01;
+  const nFeatures    = dataset[0].features.length;
+  let bias    = 0;
+  let weights = new Array(nFeatures).fill(0);
+  const positives    = dataset.filter(d => d.label === 1).length;
+  const positiveRate = positives / dataset.length;
+  if (positiveRate < 0.03) return null;
+  for (let iter = 0; iter < iterations; iter++) {
+    let dBias = 0;
+    const dWeights = new Array(nFeatures).fill(0);
+    for (const { features, label } of dataset) {
+      const error = _sigmoid(_dot(weights, features) + bias) - label;
+      dBias += error;
+      for (let j = 0; j < nFeatures; j++) dWeights[j] += error * features[j];
+    }
+    const n = dataset.length;
+    bias -= learningRate * (dBias / n);
+    for (let j = 0; j < nFeatures; j++) {
+      weights[j] -= learningRate * ((dWeights[j] / n) + lambda * weights[j]);
+    }
+  }
+  let correct = 0;
+  const threshold = positiveRate > 0.3 ? 0.5 : Math.max(0.3, positiveRate * 1.5);
+  for (const { features, label } of dataset) {
+    if ((_sigmoid(_dot(weights, features) + bias) >= threshold ? 1 : 0) === label) correct++;
+  }
+  return { bias, weights, accuracy: correct / dataset.length, positiveRate, sampleSize: dataset.length, threshold, trainedAt: new Date().toISOString() };
+}
+
+function _predictWithWeights(model, features) {
+  return Math.round(_sigmoid(_dot(model.weights, features) + model.bias) * 100);
+}
+
+const _LTV_WEIGHTS_KV_KEY = 'ltv_weights_active';
+
+async function _loadActiveWeights(env) {
+  if (env.GEO_CACHE) {
+    try {
+      const cached = await env.GEO_CACHE.get(_LTV_WEIGHTS_KV_KEY, 'json');
+      if (cached?.weights?.length) return cached;
+    } catch {}
+  }
+  if (!env.DB) return null;
+  try {
+    const row = await env.DB.prepare(
+      `SELECT weights_json FROM ltv_model_weights WHERE is_active = 1 ORDER BY trained_at DESC LIMIT 1`
+    ).first();
+    if (!row?.weights_json) return null;
+    const model = JSON.parse(row.weights_json);
+    if (env.GEO_CACHE && model?.weights?.length) {
+      env.GEO_CACHE.put(_LTV_WEIGHTS_KV_KEY, JSON.stringify(model), { expirationTtl: 604800 }).catch(() => {});
+    }
+    return model;
+  } catch { return null; }
+}
+
+async function _saveWeights(DB, model) {
+  if (!DB || !model) return;
+  await DB.prepare(`UPDATE ltv_model_weights SET is_active = 0 WHERE is_active = 1`).run();
+  await DB.prepare(`
+    INSERT INTO ltv_model_weights (trained_at, is_active, sample_size, positive_rate, accuracy, weights_json)
+    VALUES (?, 1, ?, ?, ?, ?)
+  `).bind(new Date().toISOString(), model.sampleSize, model.positiveRate, model.accuracy, JSON.stringify(model)).run();
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// MATCH QUALITY — Tracking de qualidade dos dados enviados ao Meta CAPI
+// ─────────────────────────────────────────────────────────────────────────────
+
+const _MQ_THRESHOLDS = {
+  email_rate_min: 0.40, fbp_rate_min: 0.30, composite_min: 0.45, min_events_alert: 10,
+};
+
+async function _logMatchQuality(DB, eventName, payload, recovered = {}) {
+  if (!DB) return;
+  try {
+    await DB.prepare(`
+      INSERT INTO match_quality_log (
+        event_name, has_email, has_phone, has_fbp, has_fbc, has_external_id,
+        was_email_recovered, was_utm_restored
+      ) VALUES (?,?,?,?,?,?,?,?)
+    `).bind(
+      eventName,
+      payload.email   ? 1 : 0, payload.phone    ? 1 : 0,
+      payload.fbp     ? 1 : 0, payload.fbc      ? 1 : 0,
+      payload.userId  ? 1 : 0,
+      recovered.email ? 1 : 0, recovered.utm    ? 1 : 0,
+    ).run();
+  } catch { /* não bloquear dispatch */ }
+}
+
+async function _autoEnrichPayload(env, payload) {
+  const recovered = { email: false, utm: false };
+  if (!env.DB) return { payload, recovered };
+  if (!payload.email && payload.userId) {
+    try {
+      const profile = await env.DB.prepare(
+        `SELECT email, fbp, fbc, phone FROM user_profiles WHERE user_id = ? LIMIT 1`
+      ).bind(payload.userId).first();
+      if (profile) {
+        if (profile.email && !payload.email) { payload.email = profile.email; recovered.email = true; }
+        if (profile.fbp   && !payload.fbp)   payload.fbp   = profile.fbp;
+        if (profile.fbc   && !payload.fbc)   payload.fbc   = profile.fbc;
+        if (profile.phone && !payload.phone) payload.phone = profile.phone;
+      }
+    } catch {}
+  }
+  if (payload.utmRestored) recovered.utm = true;
+  return { payload, recovered };
+}
+
+async function _analyzeMatchQuality(env) {
+  if (!env.DB) return null;
+  try {
+    const row = await env.DB.prepare(`
+      SELECT
+        COUNT(*) AS total,
+        ROUND(AVG(has_email)       * 100, 1) AS email_rate,
+        ROUND(AVG(has_phone)       * 100, 1) AS phone_rate,
+        ROUND(AVG(has_fbp)         * 100, 1) AS fbp_rate,
+        ROUND(AVG(has_fbc)         * 100, 1) AS fbc_rate,
+        ROUND(AVG(has_external_id) * 100, 1) AS ext_id_rate,
+        ROUND(AVG(was_email_recovered) * 100, 1) AS email_recovered_rate,
+        ROUND((AVG(has_email)*0.4 + AVG(has_fbp)*0.3 + AVG(has_phone)*0.2 + AVG(has_fbc)*0.1) * 100, 1) AS composite_score
+      FROM match_quality_log
+      WHERE logged_at >= datetime('now', '-2 hours')
+    `).first();
+    if (!row || row.total < _MQ_THRESHOLDS.min_events_alert) return { total: row?.total || 0, alerts: [] };
+    const alerts = [];
+    if ((row.email_rate || 0) < _MQ_THRESHOLDS.email_rate_min * 100)
+      alerts.push({ type: 'email_low',        message: `Taxa de email baixa: ${row.email_rate}%` });
+    if ((row.fbp_rate || 0) < _MQ_THRESHOLDS.fbp_rate_min * 100)
+      alerts.push({ type: 'fbp_low',          message: `Cookie fbp ausente em ${100 - row.fbp_rate}% dos eventos` });
+    if ((row.composite_score || 0) < _MQ_THRESHOLDS.composite_min * 100)
+      alerts.push({ type: 'composite_critical', message: `Score composto crítico: ${row.composite_score}%`, severity: 'critical' });
+    return { ...row, alerts };
+  } catch (err) { console.error('[MatchQuality] analyze error:', err.message); return null; }
+}
+
+async function _alertMatchQuality(env, analysis) {
+  if (!analysis || analysis.alerts.length === 0) return;
+  const hasCritical = analysis.alerts.some(a => a.severity === 'critical');
+  const icon = hasCritical ? '🚨' : '⚠️';
+  const lines = [
+    `${icon} CDP Edge — Match Quality Alert`,
+    ``,
+    `📊 Últimas 2h (${analysis.total} eventos):`,
+    `  Email: ${analysis.email_rate ?? 0}% ${(analysis.email_rate ?? 0) < 40 ? '❌' : '✅'}`,
+    `  fbp:   ${analysis.fbp_rate   ?? 0}% ${(analysis.fbp_rate   ?? 0) < 30 ? '❌' : '✅'}`,
+    `  Score: ${analysis.composite_score ?? 0}%`,
+    ``,
+    `🔍 Problemas:`,
+    ...analysis.alerts.map(a => `  · ${a.message}`),
+    ``,
+    `🛠 Identity Graph recovery: ${analysis.email_recovered_rate ?? 0}% emails recuperados`,
+    new Date().toLocaleString('pt-BR', { timeZone: 'America/Sao_Paulo' }),
+  ];
+  await sendCallMeBot(env, lines.join('\n'));
+}
+
+async function _purgeOldMatchQualityLogs(DB) {
+  if (!DB) return;
+  try {
+    await DB.prepare(`DELETE FROM match_quality_log WHERE logged_at < datetime('now', '-30 days')`).run();
+  } catch {}
+}
+
 // ── Meta CAPI v22.0 ───────────────────────────────────────────────────────────
 async function sendMetaCapi(env, eventName, payload, request, ctx) {
+  // Auto-enriquecer payload com dados do Identity Graph antes do envio
+  let recovered = { email: false, utm: false };
+  if (env.DB && payload) {
+    const enriched = await _autoEnrichPayload(env, payload);
+    payload        = enriched.payload;
+    recovered      = enriched.recovered;
+  }
+
   const {
     email, phone, firstName, lastName,
     city, state, country,
@@ -137,6 +355,13 @@ async function sendMetaCapi(env, eventName, payload, request, ctx) {
     requestBody.test_event_code = env.META_TEST_CODE;
   }
 
+  // Logar match quality em background (não bloqueia dispatch)
+  if (env.DB && ctx) {
+    ctx.waitUntil(_logMatchQuality(env.DB, eventName, payload, recovered));
+  } else if (env.DB) {
+    _logMatchQuality(env.DB, eventName, payload, recovered).catch(() => {});
+  }
+
   const endpoint = `https://graph.facebook.com/v22.0/${env.META_PIXEL_ID}/events`;
 
   try {
@@ -1569,6 +1794,30 @@ async function upsertLtvProfile(env, userId, ltv) {
  *   value: valor em BRL (base × multiplicador da classe)
  */
 async function predictLtv(env, payload, request, customSystemPrompt = null) {
+  // 0. Tentar modelo treinado (regressão logística via D1/KV)
+  try {
+    const model = await _loadActiveWeights(env);
+    if (model?.weights?.length) {
+      const hour    = new Date().getUTCHours();
+      const country = (payload.country || request.cf?.country || '').toUpperCase();
+      const features = _extractFeatures({
+        utm_source:       payload.utmSource,
+        engagement_score: parseFloat(payload.engagementScore || 0),
+        intention_level:  payload.intentionLevel,
+        days_since_lead:  0,
+        has_email:        !!payload.email,
+        has_phone:        !!payload.phone,
+        is_br:            country === 'BR',
+        hour,
+      });
+      const score100   = _predictWithWeights(model, features);
+      const ltvClass   = score100 >= 70 ? 'High' : score100 >= 40 ? 'Medium' : 'Low';
+      const multiplier = ltvClass === 'High' ? 3.5 : ltvClass === 'Medium' ? 1.8 : 0.8;
+      const base       = payload.value ? parseFloat(payload.value) : 197;
+      return { score: score100, class: ltvClass, value: Math.round(base * multiplier * 100) / 100, source: 'model' };
+    }
+  } catch { /* fallback heurístico */ }
+
   let score = 0;
 
   // 1. Engajamento browser (0–30)
@@ -1887,6 +2136,93 @@ async function auditErrorRates(env, runType) {
   return alerts;
 }
 
+// ── Treinar modelo LTV com dados reais do D1 ─────────────────────────────────
+async function _trainLtvModel(env) {
+  if (!env.DB) return { skipped: 'DB não disponível' };
+  try {
+    const rows = await env.DB.prepare(`
+      SELECT
+        l.utm_source, l.engagement_score, l.intention_level,
+        CAST(julianday('now') - julianday(l.created_at) AS INTEGER) AS days_since_lead,
+        CASE WHEN l.email IS NOT NULL AND l.email != '' THEN 1 ELSE 0 END AS has_email,
+        CASE WHEN l.phone IS NOT NULL AND l.phone != '' THEN 1 ELSE 0 END AS has_phone,
+        CASE WHEN (l.country = 'br' OR l.country = 'BR' OR l.country IS NULL) THEN 1 ELSE 0 END AS is_br,
+        CAST(strftime('%H', l.created_at) AS INTEGER) AS hour,
+        CASE WHEN EXISTS (
+          SELECT 1 FROM events e
+          WHERE e.user_id = l.user_id
+            AND e.event_name IN ('Purchase','purchase','PURCHASE')
+            AND e.created_at > l.created_at
+        ) THEN 1 ELSE 0 END AS label
+      FROM leads l
+      WHERE l.created_at >= datetime('now', '-90 days')
+      LIMIT 5000
+    `).all();
+
+    const dataset = (rows.results || []).map(row => ({ features: _extractFeatures(row), label: row.label || 0 }));
+    const model   = _trainLogisticRegression(dataset);
+
+    if (!model) {
+      console.log('[LTV Train] Dados insuficientes');
+      return { skipped: 'dados insuficientes', samples: dataset.length };
+    }
+
+    await _saveWeights(env.DB, model);
+    if (env.GEO_CACHE) env.GEO_CACHE.delete(_LTV_WEIGHTS_KV_KEY).catch(() => {});
+
+    console.log(`[LTV Train] Modelo treinado: ${dataset.length} samples, accuracy=${(model.accuracy * 100).toFixed(1)}%`);
+    return { trained: true, samples: dataset.length, accuracy: model.accuracy, positiveRate: model.positiveRate };
+  } catch (err) {
+    console.error('[LTV Train] Erro:', err.message);
+    return { error: err.message };
+  }
+}
+
+// ── Auto-decisão de winner no A/B LTV Test ────────────────────────────────────
+const _AB_LTV_CACHE_KEY = 'ab_ltv_active_test';
+
+async function _autoDecideAbWinner(env) {
+  if (!env.DB) return null;
+  try {
+    const test = await env.DB.prepare(`
+      SELECT id, min_sample_size FROM ltv_ab_tests WHERE status = 'running' ORDER BY created_at DESC LIMIT 1
+    `).first();
+    if (!test) return { decided: false };
+
+    const variations = await env.DB.prepare(`
+      SELECT id, name, is_control, sample_count, accuracy_score
+      FROM ltv_ab_variations WHERE test_id = ?
+    `).bind(test.id).all();
+
+    const vars = variations.results || [];
+    if (vars.some(v => (v.sample_count || 0) < (test.min_sample_size || 50))) return { decided: false };
+
+    const control = vars.find(v => v.is_control) || vars[0];
+    const best    = vars.reduce((a, b) => (b.accuracy_score || 0) > (a.accuracy_score || 0) ? b : a, control);
+
+    if (best.id === control.id) return { decided: false };
+
+    const improvement = (best.accuracy_score || 0) - (control.accuracy_score || 0);
+    if (improvement < 5) return { decided: false };
+
+    await env.DB.prepare(`
+      UPDATE ltv_ab_tests SET status='completed', winner_id=?, auto_decided_at=datetime('now'), auto_decided_reason=?
+      WHERE id=?
+    `).bind(best.id, `Auto: +${improvement.toFixed(1)}pp vs control`, test.id).run();
+
+    if (env.GEO_CACHE) env.GEO_CACHE.delete(_AB_LTV_CACHE_KEY).catch(() => {});
+
+    const winnerVar = await env.DB.prepare(
+      `SELECT system_prompt FROM ltv_ab_variations WHERE id = ?`
+    ).bind(best.id).first();
+
+    return { decided: true, test_id: test.id, winner_name: best.name, improvement, winning_prompt: winnerVar?.system_prompt };
+  } catch (err) {
+    console.error('[AB Auto-Decide] Erro:', err.message);
+    return null;
+  }
+}
+
 // ── Runner principal do Intelligence Agent ────────────────────────────────────
 async function runIntelligenceAgent(env, runType) {
   console.log(`[Intelligence Agent] Iniciando ${runType}`);
@@ -1907,9 +2243,45 @@ async function runIntelligenceAgent(env, runType) {
     console.warn(`[Intelligence Agent] ${errorAlerts.length} alertas de taxa de erro enviados`);
   }
 
-  // 4. Auditoria mensal adicional
+  // 4. Treinar modelo LTV com dados reais do D1 (toda semana)
+  const ltvTrainResult = await _trainLtvModel(env);
+  if (ltvTrainResult.trained) {
+    console.log(`[Intelligence Agent] LTV model treinado: accuracy=${(ltvTrainResult.accuracy * 100).toFixed(1)}%`);
+    if (env.DB) {
+      logIntelligence(env.DB, runType, 'ltv', 'model_training', 'ok',
+        `accuracy=${(ltvTrainResult.accuracy * 100).toFixed(1)}%`, null,
+        `Modelo LTV re-treinado com ${ltvTrainResult.samples} amostras`
+      ).catch(() => {});
+    }
+  }
+
+  // 5. Auto-decisão de winner no A/B LTV Test
+  try {
+    const abResult = await _autoDecideAbWinner(env);
+    if (abResult?.decided) {
+      console.log(`[Intelligence Agent] A/B winner declarado: ${abResult.winner_name}, +${abResult.improvement?.toFixed(1)}pp`);
+      await sendIntelligenceAlert(env, 'info',
+        `A/B LTV Test — Winner Declarado`,
+        `🏆 Vencedor: ${abResult.winner_name}\n📈 Melhoria: +${abResult.improvement?.toFixed(1) ?? '?'}pp vs controle\n🆔 Test ID: ${abResult.test_id}\n\n✅ Prompt vencedor ativado automaticamente`
+      );
+    }
+  } catch (err) {
+    console.error('[Intelligence Agent] A/B auto-decide error:', err.message);
+  }
+
+  // 6. Match Quality — análise + alertas
+  try {
+    const mqAnalysis = await _analyzeMatchQuality(env);
+    if (mqAnalysis) {
+      console.log(`[Intelligence Agent] Match Quality: score=${mqAnalysis.composite_score ?? 0}%, alerts=${mqAnalysis.alerts?.length ?? 0}`);
+      await _alertMatchQuality(env, mqAnalysis);
+    }
+  } catch (err) {
+    console.error('[Intelligence Agent] Match quality error:', err.message);
+  }
+
+  // 7. Auditoria mensal adicional
   if (runType === 'monthly_audit') {
-    // Verificar LTV: quantos perfis High vs Low no último mês
     if (env.DB) {
       try {
         const ltvStats = await env.DB.prepare(`
@@ -1927,14 +2299,18 @@ async function runIntelligenceAgent(env, runType) {
       } catch (err) {
         console.error('LTV audit error:', err.message);
       }
+
+      // Purge de logs antigos de match quality (> 30 dias)
+      await _purgeOldMatchQualityLogs(env.DB);
+      console.log('[Intelligence Agent] Match quality logs antigos purgados');
     }
   }
 
-  // 5. Customer Match — sync semanal D1 → Meta Custom Audience
+  // 8. Customer Match — sync semanal D1 → Meta Custom Audience
   const cmResult = await syncMetaCustomAudience(env);
   console.log(`[Intelligence Agent] Customer Match Meta: sent=${cmResult?.sent ?? 0}, received=${cmResult?.num_received ?? 0}`);
 
-  console.log(`[Intelligence Agent] ${runType} concluído`);
+  console.log(`[Intelligence Agent] ${runType} concluído — LTV model, A/B auto-decide, match quality, customer match`);
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -3404,6 +3780,21 @@ export default {
 
     const url = new URL(request.url);
 
+    // ── Rate Limiter — camada 0, antes do Fraud Gate ─────────────────────────
+    // Bloqueia na borda por IP antes de qualquer CPU ser consumida
+    // Silent drop (200) — atacante não sabe que foi bloqueado
+    // Requer binding RATE_LIMITER no wrangler.toml (Workers Paid)
+    // Fail-open: se binding não existir, deixa passar (não quebra o fluxo)
+    if (url.pathname === '/track' && request.method === 'POST' && env.RATE_LIMITER) {
+      const ip = request.headers.get('CF-Connecting-IP')
+              || request.headers.get('X-Forwarded-For')?.split(',')[0].trim()
+              || '0.0.0.0';
+      const { success } = await env.RATE_LIMITER.limit({ key: ip });
+      if (!success) {
+        return new Response(JSON.stringify({ status: 'ok', queued: true }), { status: 200, headers });
+      }
+    }
+
     // ── Fraud Gate — Fase 4 (apenas em /track e /api) ────────────────────────
     // Roda ANTES de qualquer processamento de evento
     // Silent drop (200) — bots não sabem que foram detectados

package/server-edge-tracker/wrangler.toml

@@ -82,6 +82,19 @@ crons = ["0 2 * * 7", "0 3 1 * *"]
 [ai]
 binding = "AI"
 
+# ── Rate Limiting — proteção do /track contra abuso de cota ──────────────────
+# Bloqueia na borda ANTES de qualquer processamento do Worker
+# Limite: 60 requisições por minuto por IP (generoso para usuário real)
+# Requer Workers Paid plan ($5/mês) — remover bloco se usar plano free
+[[unsafe.bindings]]
+name         = "RATE_LIMITER"
+type         = "ratelimit"
+namespace_id = "1001"
+
+[unsafe.bindings.simple]
+limit  = 60
+period = 60
+
 # ── Secrets (NÃO ficam aqui — configurar via CLI) ─────────────────────────────
 # wrangler secret put META_ACCESS_TOKEN     ← token Meta CAPI (obrigatório)
 # wrangler secret put GA4_API_SECRET        ← secret GA4 Measurement Protocol (obrigatório)