We Switched from PagerDuty to Opsgenie 2026 and Saved 30% on Incident Management Costs

// pd-to-opsgenie-migrate.go
// Migrates PagerDuty users, schedules, and escalation policies to Opsgenie
// Requires PAGERDUTY_API_KEY and OPSGENIE_API_KEY environment variables
// Uses PagerDuty API v3 (https://developer.pagerduty.com/api-reference/) and Opsgenie API v2 (https://docs.opsgenie.com/docs/api-overview)
package main

import (
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"log\"
    \"net/http\"
    \"os\"
    \"time\"

    \"github.com/PagerDuty/go-pagerduty\" // https://github.com/PagerDuty/go-pagerduty
    \"github.com/opsgenie/opsgenie-go-sdk-v2/alert\" // https://github.com/opsgenie/opsgenie-go-sdk-v2
    \"github.com/opsgenie/opsgenie-go-sdk-v2/client\"
    \"github.com/opsgenie/opsgenie-go-sdk-v2/schedule\"
    \"github.com/opsgenie/opsgenie-go-sdk-v2/escalation\"
    \"github.com/opsgenie/opsgenie-go-sdk-v2/user\"
)

func main() {
    pdAPIKey := os.Getenv(\"PAGERDUTY_API_KEY\")
    ogAPIKey := os.Getenv(\"OPSGENIE_API_KEY\")
    if pdAPIKey == \"\" || ogAPIKey == \"\" {
        log.Fatal(\"Missing required environment variables: PAGERDUTY_API_KEY, OPSGENIE_API_KEY\")
    }

    // Initialize PagerDuty client
    pdClient := pagerduty.NewClient(pdAPIKey)

    // Initialize Opsgenie client
    ogClient, err := client.NewClient(&client.ClientOptions{
        ApiKey: ogAPIKey,
    })
    if err != nil {
        log.Fatalf(\"Failed to initialize Opsgenie client: %v\", err)
    }

    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()

    // Step 1: Export all PagerDuty users
    fmt.Println(\"Exporting PagerDuty users...\")
    users, err := pdClient.ListUsersPaginated(ctx, pagerduty.ListUsersOptions{})
    if err != nil {
        log.Fatalf(\"Failed to list PagerDuty users: %v\", err)
    }
    fmt.Printf(\"Found %d PagerDuty users\\n\", len(users))

    // Step 2: Create Opsgenie users for each PagerDuty user
    ogUsers := make(map[string]string) // pdUserID -> ogUserID
    for _, pdUser := range users {
        createUserReq := &user.CreateUserRequest{
            Name:  pdUser.Name,
            Email: pdUser.Email,
            Role:  \"user\",
        }
        createdUser, err := ogClient.User.Create(ctx, createUserReq)
        if err != nil {
            log.Printf(\"Failed to create Opsgenie user for %s: %v\", pdUser.Email, err)
            continue
        }
        ogUsers[pdUser.ID] = createdUser.Id
        fmt.Printf(\"Created Opsgenie user %s for PagerDuty user %s\\n\", createdUser.Id, pdUser.ID)
    }

    // Step 3: Export PagerDuty schedules
    fmt.Println(\"Exporting PagerDuty schedules...\")
    schedules, err := pdClient.ListSchedulesPaginated(ctx, pagerduty.ListSchedulesOptions{})
    if err != nil {
        log.Fatalf(\"Failed to list PagerDuty schedules: %v\", err)
    }

    // Step 4: Create Opsgenie schedules
    for _, pdSched := range schedules {
        ogSchedReq := &schedule.CreateScheduleRequest{
            Name: pdSched.Name,
            Description: pdSched.Description,
            Enabled: true,
        }
        // Map PagerDuty schedule layers to Opsgenie rotations
        for _, layer := range pdSched.ScheduleLayers {
            ogRotation := schedule.Rotation{
                Name: fmt.Sprintf(\"%s-layer-%s\", pdSched.Name, layer.Name),
                Participants: []schedule.Participant{},
            }
            for _, userID := range layer.Users {
                if ogUserID, ok := ogUsers[userID]; ok {
                    ogRotation.Participants = append(ogRotation.Participants, schedule.Participant{
                        Type: \"user\",
                        Id:   ogUserID,
                    })
                }
            }
            ogSchedReq.Rotations = append(ogSchedReq.Rotations, ogRotation)
        }
        createdSched, err := ogClient.Schedule.Create(ctx, ogSchedReq)
        if err != nil {
            log.Printf(\"Failed to create Opsgenie schedule %s: %v\", pdSched.Name, err)
            continue
        }
        fmt.Printf(\"Created Opsgenie schedule %s (ID: %s)\\n\", createdSched.Name, createdSched.Id)
    }

    fmt.Println(\"Migration complete. Verify users and schedules in Opsgenie dashboard.\")
}

// datadog-opsgenie-webhook.go
// Receives Datadog alert webhooks, transforms payloads, and creates Opsgenie alerts
// Exposes HTTP endpoint on :8080/webhook/datadog
// Uses Opsgenie API v2 (https://docs.opsgenie.com/docs/alert-api) and Datadog webhook schema (https://docs.datadoghq.com/integrations/webhooks/)
package main

import (
    \"bytes\"
    \"context\"
    \"encoding/json\"
    \"fmt\"
    \"io\"
    \"log\"
    \"net/http\"
    \"os\"
    \"time\"

    \"github.com/opsgenie/opsgenie-go-sdk-v2/alert\" // https://github.com/opsgenie/opsgenie-go-sdk-v2
    \"github.com/opsgenie/opsgenie-go-sdk-v2/client\"
)

// DatadogWebhookPayload represents the incoming Datadog alert webhook
type DatadogWebhookPayload struct {
    AlertID      string `json:\"alert_id\"`
    AlertTitle   string `json:\"alert_title\"`
    AlertMessage string `json:\"alert_message\"`
    Severity     string `json:\"severity\"` // \"error\", \"warning\", \"info\"
    Tags         map[string]string `json:\"tags\"`
    Timestamp    int64  `json:\"timestamp\"`
}

// OpsgenieAlertPayload maps Datadog payload to Opsgenie alert request
type OpsgenieAlertPayload struct {
    Message     string `json:\"message\"`
    Description string `json:\"description\"`
    Priority    string `json:\"priority\"` // \"P1\" (SEV-1) to \"P5\" (SEV-5)
    Tags        []string `json:\"tags\"`
    Details     map[string]string `json:\"details\"`
}

func main() {
    ogAPIKey := os.Getenv(\"OPSGENIE_API_KEY\")
    if ogAPIKey == \"\" {
        log.Fatal(\"Missing required environment variable: OPSGENIE_API_KEY\")
    }

    // Initialize Opsgenie client
    ogClient, err := client.NewClient(&client.ClientOptions{
        ApiKey: ogAPIKey,
    })
    if err != nil {
        log.Fatalf(\"Failed to initialize Opsgenie client: %v\", err)
    }

    http.HandleFunc(\"/webhook/datadog\", func(w http.ResponseWriter, r *http.Request) {
        if r.Method != http.MethodPost {
            http.Error(w, \"Method not allowed\", http.StatusMethodNotAllowed)
            return
        }

        // Read request body with size limit (10MB max)
        body, err := io.ReadAll(io.LimitReader(r.Body, 10<<20))
        if err != nil {
            log.Printf(\"Failed to read request body: %v\", err)
            http.Error(w, \"Bad request\", http.StatusBadRequest)
            return
        }
        defer r.Body.Close()

        // Parse Datadog payload
        var ddPayload DatadogWebhookPayload
        if err := json.Unmarshal(body, &ddPayload); err != nil {
            log.Printf(\"Failed to parse Datadog payload: %v\", err)
            http.Error(w, \"Invalid payload\", http.StatusBadRequest)
            return
        }

        // Map Datadog severity to Opsgenie priority
        priority := \"P3\" // default
        switch ddPayload.Severity {
        case \"error\":
            priority = \"P1\"
        case \"warning\":
            priority = \"P2\"
        case \"info\":
            priority = \"P4\"
        }

        // Build Opsgenie alert request
        alertReq := &alert.CreateAlertRequest{
            Message:     ddPayload.AlertTitle,
            Description: ddPayload.AlertMessage,
            Priority:    priority,
            Tags:        []string{fmt.Sprintf(\"datadog_alert_id:%s\", ddPayload.AlertID)},
            Details:     make(map[string]string),
        }
        // Add Datadog tags as Opsgenie details
        for k, v := range ddPayload.Tags {
            alertReq.Details[fmt.Sprintf(\"datadog_tag_%s\", k)] = v
        }
        // Add timestamp to details
        alertReq.Details[\"datadog_timestamp\"] = time.Unix(ddPayload.Timestamp, 0).Format(time.RFC3339)

        // Send alert to Opsgenie
        ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
        defer cancel()
        createdAlert, err := ogClient.Alert.Create(ctx, alertReq)
        if err != nil {
            log.Printf(\"Failed to create Opsgenie alert for Datadog alert %s: %v\", ddPayload.AlertID, err)
            http.Error(w, \"Failed to create alert\", http.StatusInternalServerError)
            return
        }

        log.Printf(\"Created Opsgenie alert %s for Datadog alert %s\", createdAlert.AlertId, ddPayload.AlertID)
        w.WriteHeader(http.StatusCreated)
        json.NewEncoder(w).Encode(map[string]string{\"alert_id\": createdAlert.AlertId})
    })

    log.Println(\"Starting webhook server on :8080\")
    if err := http.ListenAndServe(\":8080\", nil); err != nil {
        log.Fatalf(\"Failed to start server: %v\", err)
    }
}

# cost-calculator.py
# Calculates incident management cost savings from migrating PagerDuty to Opsgenie
# Takes PagerDuty annual billing CSV (columns: user_count, monthly_cost_per_user, addon_cost)
# Outputs projected Opsgenie costs and savings percentage
# Uses Opsgenie 2026 pricing: https://www.opsgenie.com/pricing
import csv
import sys
from typing import Dict, List
import argparse

# Opsgenie 2026 pricing tiers (monthly per user, USD)
OPSGENIE_PRICING = {
    \"standard\": 29,
    \"advanced\": 49,
    \"enterprise\": 59,  # includes SSO, advanced analytics, custom integrations
}

def load_pagerduty_billing(csv_path: str) -> List[Dict]:
    \"\"\"Load PagerDuty billing data from CSV file.\"\"\"
    billing_data = []
    try:
        with open(csv_path, \"r\") as f:
            reader = csv.DictReader(f)
            for row in reader:
                billing_data.append({
                    \"user_count\": int(row[\"user_count\"]),
                    \"monthly_cost_per_user\": float(row[\"monthly_cost_per_user\"]),
                    \"addon_cost\": float(row[\"addon_cost\"]),
                    \"month\": row[\"month\"],
                })
    except FileNotFoundError:
        print(f\"Error: Billing file {csv_path} not found.\")
        sys.exit(1)
    except KeyError as e:
        print(f\"Error: Missing required column {e} in billing CSV.\")
        sys.exit(1)
    except ValueError as e:
        print(f\"Error: Invalid data type in billing CSV: {e}\")
        sys.exit(1)
    return billing_data

def calculate_opsgenie_cost(user_count: int, tier: str = \"enterprise\") -> float:
    \"\"\"Calculate monthly Opsgenie cost for a given user count and tier.\"\"\"
    if tier not in OPSGENIE_PRICING:
        raise ValueError(f\"Invalid Opsgenie tier: {tier}. Valid tiers: {list(OPSGENIE_PRICING.keys())}\")
    monthly_per_user = OPSGENIE_PRICING[tier]
    return user_count * monthly_per_user

def calculate_savings(pd_data: List[Dict], og_tier: str = \"enterprise\") -> Dict:
    \"\"\"Calculate total savings over 12 months.\"\"\"
    total_pd_cost = 0.0
    total_og_cost = 0.0
    for entry in pd_data:
        pd_monthly = (entry[\"user_count\"] * entry[\"monthly_cost_per_user\"]) + entry[\"addon_cost\"]
        total_pd_cost += pd_monthly
        og_monthly = calculate_opsgenie_cost(entry[\"user_count\"], og_tier)
        total_og_cost += og_monthly
    savings = total_pd_cost - total_og_cost
    savings_pct = (savings / total_pd_cost) * 100 if total_pd_cost > 0 else 0.0
    return {
        \"total_pagerduty_cost\": round(total_pd_cost, 2),
        \"total_opsgenie_cost\": round(total_og_cost, 2),
        \"total_savings\": round(savings, 2),
        \"savings_percentage\": round(savings_pct, 2),
    }

def main():
    parser = argparse.ArgumentParser(description=\"Calculate PagerDuty to Opsgenie cost savings.\")
    parser.add_argument(\"--billing-csv\", required=True, help=\"Path to PagerDuty billing CSV file\")
    parser.add_argument(\"--opsgenie-tier\", default=\"enterprise\", help=\"Opsgenie pricing tier (standard, advanced, enterprise)\")
    args = parser.parse_args()

    pd_data = load_pagerduty_billing(args.billing_csv)
    if not pd_data:
        print(\"Error: No billing data loaded.\")
        sys.exit(1)

    # Calculate average user count for summary
    avg_users = sum(entry[\"user_count\"] for entry in pd_data) / len(pd_data)
    print(f\"Loaded {len(pd_data)} months of PagerDuty billing data (avg {avg_users:.0f} users)\")

    savings = calculate_savings(pd_data, args.opsgenie_tier)
    print(\"\\n=== Cost Savings Summary ===\")
    print(f\"Total PagerDuty Cost (12 months): ${savings['total_pagerduty_cost']:.2f}\")
    print(f\"Total Opsgenie Cost (12 months): ${savings['total_opsgenie_cost']:.2f}\")
    print(f\"Total Savings: ${savings['total_savings']:.2f}\")
    print(f\"Savings Percentage: {savings['savings_percentage']:.2f}%\")

    # Warn if savings are below 20%
    if savings[\"savings_percentage\"] < 20:
        print(\"\\nWarning: Savings are below 20%. Verify Opsgenie tier and user count.\")

if __name__ == \"__main__\":
    main()

// Test stub for Datadog webhook validation
func TestDatadogWebhook_ValidPayload(t *testing.T) {
    stubPayload := DatadogWebhookPayload{
        AlertID:      \"datadog-12345\",
        AlertTitle:   \"Payment API p99 latency > 1s\",
        AlertMessage: \"Latency exceeded threshold for 5 minutes\",
        Severity:     \"error\",
        Tags:         map[string]string{\"service\": \"payments\", \"env\": \"prod\"},
        Timestamp:    time.Now().Unix(),
    }
    payloadBytes, _ := json.Marshal(stubPayload)
    req := httptest.NewRequest(http.MethodPost, \"/webhook/datadog\", bytes.NewBuffer(payloadBytes))
    w := httptest.NewRecorder()
    // Call webhook handler
    webhookHandler(w, req)
    if w.Code != http.StatusCreated {
        t.Errorf(\"Expected status 201, got %d\", w.Code)
    }
}

// Configure Opsgenie rate limiting for Kubernetes alerts
rateLimitReq := &ratelimit.CreateRateLimitRequest{
    Name:        \"k8s-pod-crash-rate-limit\",
    Description: \"Suppress duplicate k8s pod crash alerts\",
    Filter: &ratelimit.Filter{
        Tags: []string{\"k8s_pod_crash\"},
    },
    Threshold: &ratelimit.Threshold{
        Count:    5,
        Duration: \"1m\",
    },
    Action: \"suppress\",
    SuppressionDuration: \"15m\",
}
createdLimit, err := ogClient.RateLimit.Create(ctx, rateLimitReq)
if err != nil {
    log.Fatalf(\"Failed to create rate limit: %v\", err)
}

// GitHub Actions workflow snippet for schedule sync
jobs:
  sync-opsgenie-schedules:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Sync schedules to Opsgenie
        uses: opsgenie/opsgenie-schedule-sync-action@v2
        with:
          api-key: ${{ secrets.OPSGENIE_API_KEY }}
          schedule-file: \"config/opsgenie-schedules.json\"
          dry-run: false