Event Integration Services

{
  "service": "payment-webhook-service",
  "webhooks": [
    {
      "id": "stripe-webhooks",
      "provider": "stripe",
      "endpoint": "https://webhooks.acme.com/stripe",
      "signingSecret": "${STRIPE_WEBHOOK_SECRET}",
      "events": [
        "payment_intent.succeeded",
        "payment_intent.failed",
        "charge.refunded",
        "customer.subscription.created",
        "customer.subscription.deleted",
        "invoice.payment_succeeded",
        "invoice.payment_failed"
      ],
      "verification": {
        "type": "stripe-signature",
        "toleranceSeconds": 300
      }
    },
    {
      "id": "paypal-webhooks",
      "provider": "paypal",
      "endpoint": "https://webhooks.acme.com/paypal",
      "events": ["PAYMENT.CAPTURE.COMPLETED", "PAYMENT.CAPTURE.DENIED", "BILLING.SUBSCRIPTION.CREATED", "BILLING.SUBSCRIPTION.CANCELLED"],
      "verification": {
        "type": "paypal-transmission",
        "certUrl": "https://api.paypal.com/v1/notifications/verify"
      }
    }
  ],
  "routing": [
    {
      "name": "successful-payments",
      "condition": "event.type LIKE '%succeeded' OR event.type LIKE '%COMPLETED'",
      "destinations": [
        {
          "type": "http",
          "url": "https://api.acme.com/payments/process",
          "method": "POST",
          "headers": {
            "Authorization": "Bearer ${API_KEY}"
          }
        },
        {
          "type": "database",
          "connection": "postgresql://payments-db",
          "table": "payment_events"
        },
        {
          "type": "queue",
          "provider": "sqs",
          "queueUrl": "${SQS_PAYMENTS_QUEUE}"
        }
      ],
      "transform": {
        "outputFormat": "unified-payment-event",
        "mapping": {
          "id": "$.data.object.id",
          "amount": "$.data.object.amount / 100",
          "currency": "$.data.object.currency",
          "status": "'completed'",
          "customerId": "$.data.object.customer",
          "timestamp": "$.created"
        }
      }
    },
    {
      "name": "failed-payments",
      "condition": "event.type LIKE '%failed' OR event.type LIKE '%DENIED'",
      "destinations": [
        {
          "type": "http",
          "url": "https://api.acme.com/payments/failed",
          "method": "POST"
        },
        {
          "type": "slack",
          "channel": "#payment-failures",
          "template": "Payment failed: {{customer.email}} - {{amount}} {{currency}}"
        }
      ],
      "transform": {
        "outputFormat": "unified-payment-event",
        "enrich": {
          "customer": {
            "source": "api",
            "url": "https://api.acme.com/customers/{{customerId}}",
            "cache": {
              "ttl": 300
            }
          }
        }
      }
    }
  ],
  "delivery": {
    "guarantees": "at-least-once",
    "retry": {
      "maxAttempts": 5,
      "initialDelay": 1000,
      "maxDelay": 60000,
      "backoffMultiplier": 2
    },
    "timeout": 30000,
    "circuitBreaker": {
      "enabled": true,
      "failureThreshold": 5,
      "resetTimeout": 60000
    }
  }
}

// Service automatically receives and processes webhooks

// Stripe payment succeeded webhook received
// POST https://webhooks.acme.com/stripe
// Stripe-Signature: t=1234567890,v1=abc123...
// {
//   "type": "payment_intent.succeeded",
//   "data": {
//     "object": {
//       "id": "pi_abc123",
//       "amount": 9999,
//       "currency": "usd",
//       "customer": "cus_xyz789"
//     }
//   },
//   "created": 1234567890
// }

// Service automatically:
// 1. Verifies Stripe signature
// 2. Matches routing rule "successful-payments"
// 3. Transforms to unified format
// 4. Fans out to three destinations:
//    a. HTTP POST to payment processing API
//    b. INSERT into PostgreSQL database
//    c. SQS queue message
// 5. Tracks delivery to all three destinations
// 6. Retries any failed deliveries

// Monitor webhook processing
const stats = await services.events.getWebhookStats({
  webhookId: 'stripe-webhooks',
  timeRange: 'last-24h',
})
console.log(stats)
// {
//   received: 1534,
//   processed: 1534,
//   failed: 0,
//   avgProcessingTime: 234, // ms
//   deliverySuccess: 0.999,
//   byEventType: {
//     'payment_intent.succeeded': 892,
//     'payment_intent.failed': 23,
//     'charge.refunded': 45,
//     ...
//   }
// }

// Manual event replay
await services.events.replayEvent({
  eventId: 'evt_abc123',
  destinations: ['all'], // or specific destination IDs
  reason: 'reprocess-after-bug-fix',
})

// Query delivery status
const deliveries = await services.events.getDeliveryStatus({
  eventId: 'evt_abc123',
})
console.log(deliveries)
// [
//   {
//     destination: 'https://api.acme.com/payments/process',
//     status: 'delivered',
//     attempts: 1,
//     latency: 145, // ms
//     timestamp: '2024-10-27T12:34:56Z'
//   },
//   {
//     destination: 'postgresql://payments-db',
//     status: 'delivered',
//     attempts: 1,
//     latency: 23,
//     timestamp: '2024-10-27T12:34:56Z'
//   },
//   {
//     destination: 'sqs://payments-queue',
//     status: 'delivered',
//     attempts: 2, // First attempt timed out, retry succeeded
//     latency: 1234,
//     timestamp: '2024-10-27T12:35:12Z'
//   }
// ]

service: iot-event-service
ingestion:
  protocols:
    - mqtt:
        broker: mqtt://iot-broker.acme.com
        topics:
          - devices/+/temperature
          - devices/+/humidity
          - devices/+/status
          - devices/+/alert
        qos: 1
    - http:
        endpoint: https://iot-events.acme.com/ingest
        auth: api-key
    - websocket:
        endpoint: wss://iot-events.acme.com/stream
        auth: jwt
  validation:
    schema: iot-event-schema-v2
    required: [deviceId, timestamp, eventType, data]
    maxSize: 10KB
routing:
  - name: temperature-alerts
    condition: |
      eventType == 'temperature' AND
      (data.celsius > 35 OR data.celsius < 0)
    destinations:
      - type: http
        url: https://api.acme.com/alerts/temperature
        method: POST
      - type: slack
        channel: '#iot-alerts'
        severity: high
      - type: sms
        provider: twilio
        recipients: ${ON_CALL_NUMBERS}
    transform:
      alert:
        deviceId: $.deviceId
        location: $.metadata.location
        temperature: $.data.celsius
        threshold: "$.data.celsius > 35 ? 'high' : 'low'"
        timestamp: $.timestamp
  - name: time-series-storage
    condition: eventType IN ['temperature', 'humidity', 'pressure']
    destinations:
      - type: timeseries-db
        provider: influxdb
        database: iot-metrics
        measurement: sensor-readings
        tags:
          - deviceId
          - location
          - deviceType
        fields:
          - temperature: $.data.celsius
          - humidity: $.data.humidity
          - pressure: $.data.pressure
    batching:
      enabled: true
      size: 1000
      flushInterval: 5s
  - name: device-status-changes
    condition: eventType == 'status'
    destinations:
      - type: database
        connection: postgresql://device-db
        table: device_status
        operation: upsert
        conflictKeys: [deviceId]
      - type: redis
        connection: redis://cache
        key: 'device:${deviceId}:status'
        ttl: 3600
    transform:
      status:
        deviceId: $.deviceId
        status: $.data.status
        lastSeen: $.timestamp
        battery: $.data.batteryPercent
        signalStrength: $.data.rssi
delivery:
  guarantees: at-least-once
  ordering: per-device
  partitioning:
    key: $.deviceId
    partitions: 100
  retry:
    maxAttempts: 3
    initialDelay: 500
    maxDelay: 5000
  deadLetter:
    enabled: true
    destination: s3://iot-failed-events/
monitoring:
  metrics:
    enabled: true
    interval: 60s
    dimensions: [eventType, deviceId, location]
  alerts:
    - name: high-failure-rate
      condition: failureRate > 0.01
      action: pagerduty
    - name: processing-lag
      condition: lagSeconds > 60
      action: slack

// MQTT device publishes temperature reading
// Topic: devices/sensor-001/temperature
// Payload: {"celsius": 37.5, "timestamp": 1698419696}

// Service automatically:
// 1. Receives MQTT message
// 2. Validates against schema
// 3. Enriches with device metadata (location, type)
// 4. Routes to temperature-alerts (exceeds threshold)
// 5. Sends HTTP alert
// 6. Posts to Slack
// 7. Sends SMS to on-call team
// 8. Also routes to time-series storage
// 9. Batches with other readings
// 10. Writes batch to InfluxDB

// Programmatic event submission
await services.events.publish({
  deviceId: 'sensor-002',
  eventType: 'alert',
  data: {
    alertType: 'battery-low',
    batteryPercent: 5,
  },
  timestamp: new Date().toISOString(),
  metadata: {
    location: 'warehouse-a',
    deviceType: 'temperature-sensor',
  },
})

// Query event metrics
const metrics = await services.events.getMetrics({
  timeRange: 'last-hour',
  groupBy: ['eventType', 'location'],
  aggregations: ['count', 'avg', 'p95', 'p99'],
})
console.log(metrics)
// {
//   temperature: {
//     'warehouse-a': { count: 3600, avg: 22.5, p95: 28.3, p99: 31.2 },
//     'warehouse-b': { count: 3600, avg: 24.1, p95: 29.8, p99: 32.7 }
//   },
//   alert: {
//     'warehouse-a': { count: 3, avg: null, p95: null, p99: null }
//   }
// }

// Real-time event streaming
const stream = services.events.stream({
  filter: {
    deviceId: 'sensor-001',
    eventType: ['temperature', 'humidity'],
  },
})

stream.on('event', (event) => {
  console.log(`Received event from ${event.deviceId}: ${event.eventType}`)
  // Process event in real-time
})

// Event replay for debugging
await services.events.replay({
  deviceId: 'sensor-001',
  startTime: '2024-10-27T12:00:00Z',
  endTime: '2024-10-27T13:00:00Z',
  destinations: ['http://localhost:3000/debug'],
  speed: 10, // 10x speed
})

{
  "service": "order-event-service",
  "webhooks": [
    {
      "id": "shopify-orders",
      "provider": "shopify",
      "endpoint": "https://webhooks.acme.com/shopify/orders",
      "events": ["orders/create", "orders/updated", "orders/cancelled"],
      "verification": {
        "type": "hmac-sha256",
        "secret": "${SHOPIFY_WEBHOOK_SECRET}"
      }
    }
  ],
  "routing": [
    {
      "name": "new-order-workflow",
      "condition": "event.type == 'orders/create'",
      "destinations": [
        {
          "id": "inventory-check",
          "type": "http",
          "url": "https://api.acme.com/inventory/check",
          "method": "POST",
          "timeout": 5000
        },
        {
          "id": "fraud-check",
          "type": "http",
          "url": "https://api.acme.com/fraud/analyze",
          "method": "POST",
          "timeout": 3000,
          "parallel": true
        },
        {
          "id": "notification",
          "type": "email",
          "provider": "sendgrid",
          "template": "order-confirmation",
          "to": "$.customer.email",
          "dependsOn": ["inventory-check"],
          "condition": "inventory-check.response.available == true"
        },
        {
          "id": "fulfillment",
          "type": "http",
          "url": "https://api.acme.com/fulfillment/create",
          "method": "POST",
          "dependsOn": ["inventory-check", "fraud-check"],
          "condition": "inventory-check.response.available == true AND fraud-check.response.score < 0.5"
        },
        {
          "id": "analytics",
          "type": "http",
          "url": "https://api.acme.com/analytics/track",
          "method": "POST",
          "parallel": true,
          "bestEffort": true
        }
      ],
      "transform": {
        "order": {
          "orderId": "$.id",
          "orderNumber": "$.order_number",
          "customerId": "$.customer.id",
          "customerEmail": "$.customer.email",
          "total": "$.total_price",
          "currency": "$.currency",
          "items": "$.line_items[*].{sku: sku, quantity: quantity, price: price}",
          "shippingAddress": "$.shipping_address",
          "createdAt": "$.created_at"
        }
      }
    },
    {
      "name": "order-cancelled-workflow",
      "condition": "event.type == 'orders/cancelled'",
      "destinations": [
        {
          "id": "refund-payment",
          "type": "http",
          "url": "https://api.acme.com/payments/refund",
          "method": "POST"
        },
        {
          "id": "restore-inventory",
          "type": "http",
          "url": "https://api.acme.com/inventory/restore",
          "method": "POST"
        },
        {
          "id": "cancel-fulfillment",
          "type": "http",
          "url": "https://api.acme.com/fulfillment/cancel",
          "method": "POST",
          "ignoreFailure": true
        },
        {
          "id": "notification",
          "type": "email",
          "provider": "sendgrid",
          "template": "order-cancelled",
          "to": "$.customer.email"
        }
      ],
      "compensation": {
        "enabled": true,
        "onFailure": [
          {
            "when": "refund-payment fails",
            "action": "rollback restore-inventory"
          },
          {
            "when": "any fails",
            "action": "alert ops-team"
          }
        ]
      }
    }
  ],
  "delivery": {
    "guarantees": "at-least-once",
    "retry": {
      "maxAttempts": 5,
      "initialDelay": 2000,
      "maxDelay": 60000
    },
    "idempotency": {
      "enabled": true,
      "key": "$.id",
      "ttl": 86400
    }
  }
}

// Shopify order created webhook received
// Service automatically orchestrates workflow:

// Step 1: Check inventory (sequential)
// POST https://api.acme.com/inventory/check
// { "orderId": "ord_123", "items": [...] }
// Response: { "available": true }

// Step 2: Fraud check (parallel with Step 1)
// POST https://api.acme.com/fraud/analyze
// Response: { "score": 0.3, "recommendation": "approve" }

// Step 3: Send confirmation email (depends on inventory)
// POST https://sendgrid.com/v3/mail/send
// (Only executes because inventory available)

// Step 4: Create fulfillment (depends on inventory + fraud)
// POST https://api.acme.com/fulfillment/create
// (Only executes because both checks passed)

// Step 5: Track analytics (parallel, best-effort)
// POST https://api.acme.com/analytics/track
// (Executes in parallel, failures don't affect workflow)

// Query workflow status
const workflow = await services.events.getWorkflowStatus({
  eventId: 'evt_order_123',
})
console.log(workflow)
// {
//   eventId: 'evt_order_123',
//   status: 'completed',
//   startTime: '2024-10-27T12:00:00Z',
//   endTime: '2024-10-27T12:00:05Z',
//   duration: 5234, // ms
//   steps: [
//     {
//       id: 'inventory-check',
//       status: 'success',
//       attempts: 1,
//       duration: 234,
//       response: { available: true }
//     },
//     {
//       id: 'fraud-check',
//       status: 'success',
//       attempts: 1,
//       duration: 189,
//       response: { score: 0.3 }
//     },
//     {
//       id: 'notification',
//       status: 'success',
//       attempts: 1,
//       duration: 892
//     },
//     {
//       id: 'fulfillment',
//       status: 'success',
//       attempts: 1,
//       duration: 3456
//     },
//     {
//       id: 'analytics',
//       status: 'success',
//       attempts: 1,
//       duration: 123
//     }
//   ]
// }

// Handle order cancellation with compensation
// Shopify order cancelled webhook received
// Service automatically:
// 1. Refunds payment
// 2. Restores inventory
// 3. Cancels fulfillment (if still in progress)
// 4. Sends cancellation email
// 5. If refund fails, rolls back inventory restore
// 6. Alerts ops team if any step fails

// Monitor workflow performance
const metrics = await services.events.getWorkflowMetrics({
  workflowName: 'new-order-workflow',
  timeRange: 'last-24h',
})
console.log(metrics)
// {
//   executions: 1234,
//   success: 1198,
//   failed: 36,
//   avgDuration: 4567, // ms
//   p95Duration: 8923,
//   p99Duration: 12456,
//   stepMetrics: {
//     'inventory-check': { avgDuration: 245, failureRate: 0.002 },
//     'fraud-check': { avgDuration: 198, failureRate: 0.001 },
//     'fulfillment': { avgDuration: 3456, failureRate: 0.028 }
//   }
// }

service: cicd-event-service
webhooks:
  - id: github-push
    provider: github
    endpoint: https://webhooks.acme.com/github
    events:
      - push
      - pull_request
      - release
    verification:
      type: github-signature
      secret: ${GITHUB_WEBHOOK_SECRET}
routing:
  - name: build-and-deploy
    condition: |
      event.type == 'push' AND
      event.ref == 'refs/heads/main' AND
      event.repository.name NOT IN ['docs', 'notes']
    destinations:
      - id: trigger-build
        type: http
        url: https://ci.acme.com/build
        method: POST
        transform:
          build:
            repository: $.repository.full_name
            branch: $.ref | split('/') | .[-1]
            commit: $.after
            author: $.pusher.name
            message: $.head_commit.message
      - id: notify-slack
        type: slack
        channel: '#deployments'
        template: |
          🚀 Build triggered for *{{repository}}*
          Branch: {{branch}}
          Commit: {{commit | truncate(7)}}
          Author: {{author}}
  - name: build-completed
    condition: event.type == 'build.completed'
    destinations:
      - id: run-tests
        type: http
        url: https://ci.acme.com/test
        method: POST
        condition: event.status == 'success'
      - id: notify-failure
        type: slack
        channel: '#deployments'
        template: '❌ Build failed for {{repository}}: {{error}}'
        condition: event.status == 'failed'
  - name: tests-passed
    condition: event.type == 'tests.completed' AND event.status == 'success'
    destinations:
      - id: build-docker-image
        type: http
        url: https://docker-builder.acme.com/build
        method: POST
      - id: notify-slack
        type: slack
        channel: '#deployments'
        template: '✅ Tests passed for {{repository}}'
  - name: docker-image-ready
    condition: event.type == 'image.built'
    destinations:
      - id: deploy-staging
        type: http
        url: https://k8s-deployer.acme.com/deploy
        method: POST
        transform:
          deployment:
            environment: staging
            image: $.image
            tag: $.tag
      - id: run-e2e-tests
        type: http
        url: https://ci.acme.com/e2e
        method: POST
        dependsOn: [deploy-staging]
  - name: staging-validated
    condition: |
      event.type == 'e2e-tests.completed' AND
      event.status == 'success' AND
      event.environment == 'staging'
    destinations:
      - id: deploy-production
        type: http
        url: https://k8s-deployer.acme.com/deploy
        method: POST
        transform:
          deployment:
            environment: production
            image: $.image
            tag: $.tag
            strategy: canary
            canaryWeight: 10
      - id: notify-slack
        type: slack
        channel: '#deployments'
        template: |
          🎉 Deployed to production!
          Image: {{image}}:{{tag}}
          Strategy: Canary (10%)
delivery:
  guarantees: at-least-once
  retry:
    maxAttempts: 3
    initialDelay: 1000
  timeout: 300000 # 5 minutes for long-running builds
monitoring:
  tracing:
    enabled: true
    provider: jaeger
  metrics:
    enabled: true
    provider: prometheus

// Developer pushes to main branch
// GitHub webhook received
// Service automatically triggers pipeline:

// Event 1: push (from GitHub)
// → Triggers build
// → Notifies Slack

// Event 2: build.completed (from CI)
// → Runs tests
// → (or notifies failure)

// Event 3: tests.completed (from CI)
// → Builds Docker image
// → Notifies Slack

// Event 4: image.built (from Docker builder)
// → Deploys to staging
// → Runs E2E tests (after staging ready)

// Event 5: e2e-tests.completed (from CI)
// → Deploys to production (canary)
// → Notifies Slack

// Trace complete pipeline
const trace = await services.events.getTrace({
  correlationId: 'commit-abc123',
})
console.log(trace)
// {
//   correlationId: 'commit-abc123',
//   startTime: '2024-10-27T12:00:00Z',
//   endTime: '2024-10-27T12:15:23Z',
//   totalDuration: 923000, // 15m 23s
//   events: [
//     {
//       type: 'push',
//       timestamp: '2024-10-27T12:00:00Z',
//       source: 'github'
//     },
//     {
//       type: 'build.completed',
//       timestamp: '2024-10-27T12:03:45Z',
//       duration: 225000, // 3m 45s
//       status: 'success'
//     },
//     {
//       type: 'tests.completed',
//       timestamp: '2024-10-27T12:08:12Z',
//       duration: 267000, // 4m 27s
//       status: 'success'
//     },
//     {
//       type: 'image.built',
//       timestamp: '2024-10-27T12:10:34Z',
//       duration: 142000, // 2m 22s
//       image: 'acme/app:abc123'
//     },
//     {
//       type: 'deployment.staging',
//       timestamp: '2024-10-27T12:11:45Z',
//       duration: 71000, // 1m 11s
//       status: 'success'
//     },
//     {
//       type: 'e2e-tests.completed',
//       timestamp: '2024-10-27T12:14:12Z',
//       duration: 147000, // 2m 27s
//       status: 'success'
//     },
//     {
//       type: 'deployment.production',
//       timestamp: '2024-10-27T12:15:23Z',
//       duration: 71000, // 1m 11s
//       status: 'success'
//     }
//   ]
// }

// Pipeline metrics
const metrics = await services.events.getPipelineMetrics({
  repository: 'acme/app',
  timeRange: 'last-30-days',
})
console.log(metrics)
// {
//   totalDeployments: 234,
//   successRate: 0.923,
//   avgDuration: 892000, // ~15 minutes
//   p95Duration: 1234000,
//   failuresByStage: {
//     build: 8,
//     tests: 12,
//     staging: 2,
//     e2e: 3,
//     production: 0
//   }
// }

{
  "service": "customer-comms-service",
  "routing": [
    {
      "name": "welcome-series",
      "condition": "event.type == 'user.signup'",
      "destinations": [
        {
          "id": "welcome-email-immediate",
          "type": "email",
          "provider": "sendgrid",
          "template": "welcome-email-1",
          "to": "$.user.email",
          "delay": 0
        },
        {
          "id": "welcome-email-day2",
          "type": "email",
          "provider": "sendgrid",
          "template": "welcome-email-2",
          "to": "$.user.email",
          "delay": 172800000,
          "condition": "$.user.lastLogin == null"
        },
        {
          "id": "welcome-email-day7",
          "type": "email",
          "provider": "sendgrid",
          "template": "welcome-email-3",
          "to": "$.user.email",
          "delay": 604800000,
          "condition": "$.user.trialActive == true"
        }
      ],
      "preferences": {
        "respectUnsubscribe": true,
        "respectQuietHours": true,
        "quietHours": {
          "start": "22:00",
          "end": "08:00",
          "timezone": "$.user.timezone"
        }
      }
    },
    {
      "name": "transactional-notifications",
      "condition": "event.type IN ['order.placed', 'payment.received', 'shipment.dispatched']",
      "destinations": [
        {
          "id": "email",
          "type": "email",
          "provider": "sendgrid",
          "template": "$.event.type | replace('.', '-')",
          "to": "$.customer.email"
        },
        {
          "id": "sms",
          "type": "sms",
          "provider": "twilio",
          "to": "$.customer.phone",
          "condition": "$.customer.preferences.smsEnabled == true"
        },
        {
          "id": "push",
          "type": "push",
          "provider": "onesignal",
          "to": "$.customer.id",
          "condition": "$.customer.preferences.pushEnabled == true"
        }
      ],
      "channelOrdering": ["push", "sms", "email"],
      "deduplication": {
        "enabled": true,
        "window": 300000,
        "key": "$.orderId"
      }
    },
    {
      "name": "abandoned-cart",
      "condition": "event.type == 'cart.abandoned'",
      "destinations": [
        {
          "id": "reminder-email-1h",
          "type": "email",
          "provider": "sendgrid",
          "template": "cart-reminder-1",
          "to": "$.customer.email",
          "delay": 3600000
        },
        {
          "id": "reminder-email-24h",
          "type": "email",
          "provider": "sendgrid",
          "template": "cart-reminder-2",
          "to": "$.customer.email",
          "delay": 86400000,
          "condition": "$.cart.total > 50",
          "enrich": {
            "discount": {
              "source": "api",
              "url": "https://api.acme.com/discounts/generate",
              "method": "POST",
              "body": {
                "customerId": "$.customer.id",
                "cartTotal": "$.cart.total",
                "discountPercent": 10
              }
            }
          }
        }
      ],
      "cancellation": {
        "enabled": true,
        "events": ["cart.purchased", "cart.cleared"]
      }
    }
  ],
  "delivery": {
    "guarantees": "at-least-once",
    "retry": {
      "maxAttempts": 3,
      "initialDelay": 5000
    },
    "tracking": {
      "opens": true,
      "clicks": true,
      "conversions": true
    }
  }
}

// User signs up
await services.events.publish({
  type: 'user.signup',
  user: {
    id: 'user_123',
    email: '[email protected]',
    timezone: 'America/Los_Angeles'
  },
  timestamp: new Date().toISOString()
});

// Service automatically:
// 1. Sends welcome email immediately
// 2. Schedules follow-up email for 2 days later
// 3. Schedules trial reminder for 7 days later
// 4. Respects quiet hours (8pm-8am Pacific)

// Order placed
await services.events.publish({
  type: 'order.placed',
  orderId: 'ord_123',
  customer: {
    id: 'user_123',
    email: '[email protected]',
    phone: '+14155551234',
    preferences: {
      smsEnabled: true,
      pushEnabled: true
    }
  },
  total: 99.99
});

// Service automatically:
// 1. Sends order confirmation email
// 2. Sends SMS notification (based on preferences)
// 3. Sends push notification (based on preferences)
// 4. Deduplicates if multiple order.placed events within 5 minutes

// Abandoned cart with follow-up
await services.events.publish({
  type: 'cart.abandoned',
  cartId: 'cart_456',
  customer: {
    id: 'user_789',
    email: '[email protected]'
  },
  cart: {
    total: 149.99,
    items: [...]
  }
});

// Service automatically:
// 1. Schedules reminder email for 1 hour later
// 2. Schedules second reminder for 24 hours with 10% discount
// 3. Cancels reminders if user purchases or clears cart

// Query communication analytics
const analytics = await services.events.getCommAnalytics({
  userId: 'user_123',
  timeRange: 'last-30-days'
});
console.log(analytics);
// {
//   emailsSent: 15,
//   emailsOpened: 12,
//   emailsClicked: 7,
//   smsSent: 8,
//   pushSent: 23,
//   pushOpened: 19,
//   conversions: 3,
//   unsubscribed: false
// }

// Cancel scheduled communications
await services.events.cancelScheduled({
  userId: 'user_123',
  type: 'welcome-series'
});

Tier 1 (0 - 1M events/month):        $0.0005 per event = $500
Tier 2 (1M - 10M events/month):      $0.0003 per event = $3,000
Tier 3 (10M - 100M events/month):    $0.0001 per event = $10,000
Tier 4 (100M+ events/month):         $0.00005 per event

Premium Features:
- Transformation: +$0.0001 per event
- Enrichment: +$0.0002 per event
- Guaranteed ordering: +50% base price
- Exactly-once delivery: +100% base price

Standard Webhook Endpoint:
- $99/month per endpoint
- Includes 500K events/month
- Overage: $0.0003 per event

Premium Webhook (High-volume):
- $499/month per endpoint
- Includes 5M events/month
- Overage: $0.0001 per event
- Priority processing included
- 99.99% SLA

Starter:
- $200/month base
- 5 webhook endpoints
- 1M events/month included
- Basic routing and transformation
- 99.9% SLA
- Overage: $0.0005 per event

Professional:
- $1,000/month base
- 25 webhook endpoints
- 10M events/month included
- Advanced routing and workflows
- Real-time streaming
- 99.95% SLA
- Overage: $0.0002 per event

Enterprise:
- $5,000/month base
- Unlimited webhook endpoints
- 100M events/month included
- Custom transformations
- Dedicated infrastructure
- 99.99% SLA
- Premium support
- Overage: $0.0001 per event

Real-time Streaming:              +$500/month
Advanced Transformations:         +$0.0002 per event
External Enrichment:              +$0.0005 per event
Long-term Event Storage:          +$0.10 per GB/month
Event Replay:                     +$0.001 per replayed event
Custom Integrations:              +$2,000 one-time
Dedicated Support:                +$2,000/month
Priority Processing:              +$1,000/month
99.99% SLA:                       +$1,500/month

Ingestion (inbound):         Included
Delivery (outbound):         $0.01 per GB
Inter-region transfer:       $0.02 per GB
Webhooks (HTTP):             $0.005 per 1000 requests
Message queues:              $0.001 per 1000 messages

// Good event design
const event = {
  id: 'evt_abc123',
  type: 'order.placed',
  version: '1.0',
  timestamp: '2024-10-27T12:00:00Z',
  data: {
    orderId: 'ord_123',
    customerId: 'cus_456',
    total: 99.99,
    currency: 'USD'
  },
  metadata: {
    source: 'web-app',
    correlationId: 'session_xyz',
    causationId: 'evt_abc122'
  }
};

// Event versioning for evolution
const eventV2 = {
  ...event,
  version: '2.0',
  data: {
    ...event.data,
    items: [...], // New field
    shippingMethod: 'express' // New field
  }
};

services.events.on('delivery.failed', async (event) => {
  console.error(`Delivery failed for event ${event.id}`)

  if (event.retriesRemaining > 0) {
    // Automatic retry
    console.log(`Retrying in ${event.nextRetryDelay}ms`)
  } else {
    // Move to dead letter queue
    await services.events.moveToDeadLetter({
      eventId: event.id,
      reason: event.error,
      destination: 's3://failed-events/',
    })

    // Alert operations team
    await alerting.send({
      severity: 'high',
      message: `Event ${event.id} moved to DLQ after ${event.attempts} attempts`,
    })
  }
})

// Key metrics to monitor
const metrics = {
  eventsIngested: 'counter',
  eventsDelivered: 'counter',
  eventsRetried: 'counter',
  eventsFailed: 'counter',
  processingLatency: 'histogram',
  deliveryLatency: 'histogram',
  queueDepth: 'gauge',
}

// Alerting rules
const alerts = [
  {
    name: 'high-failure-rate',
    condition: 'eventsFailed / eventsIngested > 0.05',
    severity: 'high',
  },
  {
    name: 'processing-lag',
    condition: 'queueDepth > 10000',
    severity: 'warning',
  },
  {
    name: 'delivery-latency',
    condition: 'p95(deliveryLatency) > 10000', // 10 seconds
    severity: 'warning',
  },
]