AWS CloudWatch

import https from 'node:https';
import { URL } from 'node:url';

const SEVERITY_MAP = {
  crit: 'critical', critical: 'critical', sev1: 'critical', p1: 'critical',
  high: 'high', sev2: 'high', p2: 'high',
  warn: 'warning', warning: 'warning', sev3: 'warning', p3: 'warning',
  info: 'info', low: 'info', sev4: 'info', p4: 'info',
};

const str = (v) => (v === null || v === undefined ? '' : String(v));

function parseRegionFromArn(arn) {
  const parts = str(arn).split(':');
  return parts.length >= 4 ? parts[3] : '';
}

function resolveSeverity(alarmDescription, alarmName) {
  const m = str(alarmDescription).match(/\[severity:([a-zA-Z0-9]+)\]/);
  if (m) return SEVERITY_MAP[m[1].toLowerCase()] || 'warning';
  const name = str(alarmName).toLowerCase();
  for (const k of ['critical', 'high', 'warning', 'info']) {
    if (name.includes(k)) return k;
  }
  return 'warning';
}

function extractServiceHint(trigger, alarmName) {
  if (!trigger || typeof trigger !== 'object') return str(alarmName);
  const dims = trigger.Dimensions || {};
  const byNamespace = {
    'AWS/ECS': ['ServiceName', 'ClusterName'],
    'AWS/RDS': ['DBClusterIdentifier', 'DBInstanceIdentifier'],
    'AWS/DynamoDB': ['TableName'],
    'AWS/Lambda': ['FunctionName'],
    'AWS/EC2': ['InstanceId'],
    'AWS/ApplicationElb': ['LoadBalancer'],
    'AWS/ApiGateway': ['ApiName'],
    'AWS/SQS': ['QueueName'],
    'AWS/S3': ['BucketName'],
  };
  for (const k of byNamespace[trigger.Namespace] || []) {
    if (dims[k]) return str(dims[k]);
  }
  const ns = str(trigger.Namespace).replace(/^(AWS\/|ECS\/|EKS\/)/, '');
  return ns || str(alarmName);
}

function toCanonical(msg) {
  const alarmArn = str(msg.AlarmArn);
  const alarmName = str(msg.AlarmName);
  const region = parseRegionFromArn(alarmArn) || process.env.REGION || '';
  const trigger = msg.Trigger || null;
  return {
    schema: 'aciona.cloudwatch.v1',
    source: 'aws_cloudwatch',
    alarmName,
    alarmArn,
    awsAccountId: str(msg.AWSAccountId),
    region,
    state: str(msg.NewStateValue).toUpperCase(),
    oldState: str(msg.OldStateValue).toUpperCase(),
    reason: str(msg.NewStateReason),
    stateChangeTime: str(msg.StateChangeTime),
    severity: resolveSeverity(msg.AlarmDescription, alarmName),
    service: extractServiceHint(trigger, alarmName),
    dimensions: trigger?.Dimensions || null,
    trigger: trigger
      ? {
          metricName: trigger.MetricName,
          namespace: trigger.Namespace,
          statistic: trigger.Statistic,
          period: trigger.Period,
          evaluationPeriods: trigger.EvaluationPeriods,
          comparisonOperator: trigger.ComparisonOperator,
          threshold: trigger.Threshold,
        }
      : null,
    alarmDescription: str(msg.AlarmDescription),
    url: region && alarmName
      ? `https://console.aws.amazon.com/cloudwatch/home?region=${region}#alarmsAlarm:alarmName=${encodeURIComponent(alarmName)}`
      : '',
  };
}

function postToIngress(payload) {
  return new Promise((resolve, reject) => {
    const url = new URL(process.env.ACIONA_INGRESS_URL);
    const body = JSON.stringify(payload);
    const req = https.request(
      {
        method: 'POST',
        hostname: url.hostname,
        path: url.pathname + url.search,
        headers: {
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(body),
          'X-Aciona-Token': process.env.ACIONA_TOKEN,
        },
      },
      (res) => {
        let data = '';
        res.on('data', (c) => (data += c));
        res.on('end', () => {
          if (res.statusCode >= 200 && res.statusCode < 300) resolve(data);
          else reject(new Error(`HTTP ${res.statusCode}: ${data}`));
        });
      },
    );
    req.on('error', reject);
    req.write(body);
    req.end();
  });
}

export const handler = async (event) => {
  const results = [];
  for (const record of event.Records || []) {
    try {
      const canonical = toCanonical(JSON.parse(record.Sns.Message));
      await postToIngress(canonical);
      results.push({ ok: true, alarmArn: canonical.alarmArn });
    } catch (err) {
      console.error('[aciona.me] falha no registro SNS', err.message);
      results.push({ ok: false, error: err.message });
    }
  }
  if (results.length > 0 && results.every((r) => !r.ok)) {
    throw new Error('Todos os registros falharam');
  }
  return { batch: results };
};