Alerts 동작 방식

struct AlertChannel {
    id: String,                        // UUID v7
    name: String,                      // Human-readable name
    alert_channel_type: AlertChannelType, // http | slack_webhook | slack_web_api
    metadata_json: AlertChannelData,   // Type-specific configuration
    created_at: i64,                   // Unix timestamp
    updated_at: i64,                   // Unix timestamp
    deleted_at: Option<i64>,           // Soft-delete timestamp
}

// HTTP Webhook
struct AlertChannelHttpData {
    url: String,
    method: Option<HttpMethod>,        // POST | PATCH | PUT | DELETE
    headers: Option<HashMap<String, String>>,
    proxy: Option<String>,
}
 
// Slack Webhook
struct AlertChannelSlackWebhookData {
    webhook_url: String,
    proxy: Option<String>,
}
 
// Slack Web API
struct AlertChannelSlackWebApiData {
    token: String,                     // Bot token (xoxb-)
    channel: String,                   // Channel ID or name
    proxy: Option<String>,
}

struct Alert {
    id: String,                            // UUID v7
    title: String,                         // Human-readable title
    event_type: AlertEventType,            // deployment_workload_metrics | etc
    event_targets: EventTargets,           // None | All | Specific
    event_rule_expression: String,         // JavaScript expression
    event_rule_check_interval_min: i32,    // Evaluation frequency
    alert_messages_json: Vec<AlertMessage>,// Messages to send
    created_at: i64,                       // Unix timestamp
    updated_at: i64,                       // Unix timestamp
    deleted_at: Option<i64>,               // Soft-delete timestamp
}

enum EventTargets {
    None,                                  // Disabled
    All {
        resource_type: ResourceType        // deployment
    },
    Specific(Vec<Resource>)                // Targeted resources
}
 
struct Resource {
    resource_type: ResourceType,           // deployment
    namespace: Option<String>,             // None = all namespaces
    name: Option<String>,                  // None = all names
}

struct AlertMessage {
    alert_channel_id: String,              // Reference to AlertChannel.id
    message: String,                       // Template with ${variable} syntax
}

struct AlertLog {
    id: String,                            // UUID v7
    alert_log_group_id: String,            // Groups logs from same evaluation
    alert_channel_id: String,              // Which channel was used
    alert_id: String,                      // Which alert fired
    alert_title: String,                   // Alert title (denormalized)
    response_json: String,                 // HTTP response body
    is_error: bool,                        // Success/failure flag
    reason: String,                        // Error details
    created_at: i64,                       // Unix timestamp
}

evaluation_period_minutes >= 5 &&
(max(cpu_utilization_arr) >= 80 || avg(memory_utilization_arr) >= 80)

🔴 ${alert_title}

Workload: ${namespace}/${workload_name}
CPU Usage: ${max(cpu_utilization_arr)}%
Memory Usage: ${avg(memory_utilization_arr)}%
Evaluation Period: ${evaluation_period_minutes} minutes
Time: ${alert_time}

phase == "START" || phase == "END"

📦 Deployment ${phase == "START" ? "Started" : "Ended"}

${scheduling_title}: ${deployment_count} deployment(s) ${phase == "START" ? "started" : "ended"}
Time: ${alert_time}

missing_duration_minutes >= 3 && error_duration_minutes >= 1

⚠️ Autopilot Logs Missing

Workload: ${namespace}/${workload_name}
Missing for: ${missing_duration_minutes} minutes
Action: Check Autopilot pod health
Time: ${alert_time}

POST /webhook HTTP/1.1
Host: example.com
Content-Type: application/json
Authorization: Bearer <token>
User-Agent: WaveAutoscale/1.0
 
{
  "text": "<rendered message>"
}

POST /services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXX HTTP/1.1
Host: hooks.slack.com
Content-Type: application/json
 
{
  "text": "<rendered message>"
}

POST /api/chat.postMessage HTTP/1.1
Host: slack.com
Content-Type: application/json
Authorization: Bearer xoxb-<token>
 
{
  "channel": "C1234567890",
  "text": "<rendered message>"
}

{
  "is_valid": false,
  "error": "Syntax error: Unexpected token '}'",
  "metadata": null
}

{
  "is_valid": false,
  "error": "Invalid fields used: unknown_field. Allowed fields: cpu_utilization_arr, memory_utilization_arr",
  "metadata": {
    "used_fields": ["unknown_field"],
    "preview": null
  }
}

max(array)  // Maximum value
min(array)  // Minimum value
avg(array)  // Average (mean) value
sum(array)  // Sum of all values

// Alert if max CPU in last 5min > 80% AND avg memory > 70%
evaluation_period_minutes >= 5 &&
max(cpu_utilization_arr) > 80 &&
avg(memory_utilization_arr) > 70

// Without period requirement (alerts every minute if CPU > 80%)
max(cpu_utilization_arr) > 80
 
// With period requirement (alerts only if sustained 5+ minutes)
evaluation_period_minutes >= 5 && max(cpu_utilization_arr) > 80

{
  "alert_messages_json": [
    {
      "alert_channel_id": "pagerduty-prod",
      "message": "CRITICAL: ${alert_title} - ${namespace}/${workload_name}"
    },
    {
      "alert_channel_id": "slack-ops",
      "message": "⚠️ Alert: ${alert_title}\nWorkload: ${namespace}/${workload_name}\nCPU: ${max(cpu_utilization_arr)}%"
    }
  ]
}

{
  "type": "http",
  "data": {
    "url": "https://external-api.example.com/webhook",
    "proxy": "http://proxy.corp.example.com:8080"
  }
}

http://username:password@proxy.corp.example.com:8080