Build with ProLayer

curl -X POST https://api.prolayer.io/v1/templates \
  -H "Authorization: Bearer pl_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "cpu_alert",
    "channel": "slack",
    "body": "🔴 CPU Alert on {{server}}\nCurrent: {{value}}% (threshold: {{threshold}}%)\nDuration: {{duration}}\nDashboard: {{dashboardUrl}}",
    "variables": ["server", "value", "threshold", "duration", "dashboardUrl"]
  }'

{
  "id": "tpl_r4s5t6u7v8w9",
  "name": "cpu_alert",
  "channel": "slack",
  "body": "🔴 CPU Alert on {{server}}\nCurrent: {{value}}% (threshold: {{threshold}}%)\nDuration: {{duration}}\nDashboard: {{dashboardUrl}}",
  "variables": ["server", "value", "threshold", "duration", "dashboardUrl"],
  "created_at": "2025-03-15T10:00:00Z",
  "updated_at": "2025-03-15T10:00:00Z"
}

curl -X POST https://api.prolayer.io/v1/webhooks \
  -H "Authorization: Bearer pl_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://yourapp.com/webhooks/prolayer",
    "events": [
      "alert.sent",
      "alert.delivered",
      "alert.acknowledged",
      "alert.failed"
    ],
    "secret": "whsec_your_signing_secret_here"
  }'

{
  "id": "evt_m3n4o5p6q7r8",
  "type": "alert.delivered",
  "created_at": "2025-03-15T14:30:02Z",
  "data": {
    "notification_id": "ntf_a1b2c3d4e5f6",
    "channel": "slack",
    "to": "team_engineering",
    "status": "delivered",
    "severity": "warning",
    "acknowledged": false,
    "sent_at": "2025-03-15T14:30:00Z",
    "delivered_at": "2025-03-15T14:30:02Z",
    "metadata": {
      "server": "prod-server-3",
      "metric": "cpu",
      "value": 94
    }
  }
}

import crypto from "crypto";

function verifyWebhookSignature(
  payload: string,
  signature: string,
  secret: string
): boolean {
  const expected = crypto
    .createHmac("sha256", secret)
    .update(payload, "utf-8")
    .digest("hex");

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// In your webhook handler:
app.post("/webhooks/prolayer", (req, res) => {
  const signature = req.headers["x-prolayer-signature"] as string;
  const isValid = verifyWebhookSignature(
    JSON.stringify(req.body),
    signature,
    process.env.PROLAYER_WEBHOOK_SECRET!
  );

  if (!isValid) {
    return res.status(401).send("Invalid signature");
  }

  // Process the event...
  const { type, data } = req.body;
  console.log(`Event: ${type}, Notification: ${data.notification_id}`);

  res.status(200).send("OK");
});

{
  "error": {
    "type": "invalid_request_error",
    "code": "missing_required_field",
    "message": "The 'to' field is required when sending a notification.",
    "param": "to",
    "status": 400,
    "request_id": "req_a1b2c3d4e5f6"
  }
}

import ProLayer, { ProLayerError } from "@prolayer/sdk";

const client = new ProLayer({ apiKey: process.env.PROLAYER_API_KEY });

try {
  await client.notifications.send({
    channel: "slack",
    to: "team_engineering",
    message: "Deploy v2.4.1 completed on production",
  });
} catch (error) {
  if (error instanceof ProLayerError) {
    switch (error.status) {
      case 400:
        console.error("Bad request:", error.message);
        break;
      case 401:
        console.error("Invalid API key");
        break;
      case 429:
        const retryAfter = error.headers["retry-after"];
        console.log(`Rate limited. Retry after ${retryAfter}s`);
        break;
      case 500:
      case 503:
        console.error("Server error, retrying...");
        // Implement exponential backoff
        break;
    }
  }
}

HTTP/1.1 200 OK
X-RateLimit-Limit: 2000
X-RateLimit-Remaining: 1847
X-RateLimit-Reset: 1710510600
Retry-After: 42

async function fetchAllNotifications() {
  const allNotifications = [];
  let cursor: string | undefined;

  do {
    const page = await client.notifications.list({
      limit: 100,
      cursor,
    });

    allNotifications.push(...page.data);
    cursor = page.has_more ? page.cursor : undefined;
  } while (cursor);

  return allNotifications;
}

// Example: wrapping ProLayer behind an adapter for gradual migration

interface AlertProvider {
  send(params: {
    channel: string;
    to: string;
    message: string;
    severity?: string;
  }): Promise<{ id: string; status: string }>;
}

class ProLayerProvider implements AlertProvider {
  private client: ProLayer;

  constructor(apiKey: string) {
    this.client = new ProLayer({ apiKey });
  }

  async send(params: { channel: string; to: string; message: string; severity?: string }) {
    const result = await this.client.notifications.send(params);
    return { id: result.id, status: result.status };
  }
}

// Use a feature flag to switch providers
const provider: AlertProvider = featureFlags.useProLayer
  ? new ProLayerProvider(process.env.PROLAYER_API_KEY!)
  : legacyAlertProvider;

await provider.send({
  channel: "slack",
  to: "team_engineering",
  message: "CPU alert: prod-server-3 at 94%",
  severity: "warning",
});