Alerts API

name: Deploy and Monitor
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Deploy Application
        run: ./deploy.sh
        
      - name: Create Alert on Failure
        if: failure()
        run: |
          curl -X POST "https://api.warrn.io/api/alerts/" \
            -H "X-API-Key: ${{ secrets.WARRN_API_KEY }}" \
            -H "Content-Type: application/json" \
            -d '{
              "name": "Deployment Failed",
              "description": "Production deployment failed for commit ${{ github.sha }}",
              "severity": "critical",
              "tags": ["deployment", "production", "ci-cd"],
              "metadata": {
                "commit": "${{ github.sha }}",
                "branch": "${{ github.ref_name }}",
                "workflow": "${{ github.workflow }}",
                "run_id": "${{ github.run_id }}"
              }
            }'

pipeline {
    agent any
    
    stages {
        stage('Deploy') {
            steps {
                script {
                    try {
                        sh './deploy.sh'
                    } catch (Exception e) {
                        // Create alert on deployment failure
                        sh """
                        curl -X POST "https://api.warrn.io/api/alerts/" \\
                          -H "X-API-Key: ${env.WARRN_API_KEY}" \\
                          -H "Content-Type: application/json" \\
                          -d '{
                            "name": "Jenkins Deployment Failed",
                            "description": "Deployment failed in Jenkins job ${env.JOB_NAME}",
                            "severity": "critical",
                            "tags": ["jenkins", "deployment", "failure"],
                            "metadata": {
                              "job_name": "${env.JOB_NAME}",
                              "build_number": "${env.BUILD_NUMBER}",
                              "build_url": "${env.BUILD_URL}"
                            }
                          }'
                        """
                        throw e
                    }
                }
            }
        }
    }
}

# alertmanager_webhook.py
from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

WARRN_API_KEY = "warrn_your_api_key_here"
WARRN_API_URL = "https://api.warrn.io/api/alerts/"

@app.route('/webhook', methods=['POST'])
def alertmanager_webhook():
    data = request.json
    
    for alert in data.get('alerts', []):
        # Convert Prometheus alert to Warrn alert
        warrn_alert = {
            "name": alert.get('labels', {}).get('alertname', 'Unknown Alert'),
            "description": alert.get('annotations', {}).get('description', ''),
            "severity": map_prometheus_severity(alert.get('labels', {}).get('severity', 'warning')),
            "tags": [
                alert.get('labels', {}).get('job', ''),
                alert.get('labels', {}).get('instance', ''),
                "prometheus"
            ],
            "metadata": {
                "prometheus_labels": alert.get('labels', {}),
                "prometheus_annotations": alert.get('annotations', {}),
                "generator_url": alert.get('generatorURL', '')
            }
        }
        
        # Send to Warrn
        response = requests.post(
            WARRN_API_URL,
            headers={
                "X-API-Key": WARRN_API_KEY,
                "Content-Type": "application/json"
            },
            json=warrn_alert
        )
        
        print(f"Alert sent to Warrn: {response.status_code}")
    
    return jsonify({"status": "ok"})

def map_prometheus_severity(prom_severity):
    mapping = {
        "critical": "critical",
        "warning": "medium", 
        "info": "low"
    }
    return mapping.get(prom_severity, "medium")

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

# error_tracker.py
import requests
import traceback
from functools import wraps

class WarrnErrorTracker:
    def __init__(self, api_key, service_id=None, team_id=None):
        self.api_key = api_key
        self.service_id = service_id
        self.team_id = team_id
        self.api_url = "https://api.warrn.io/api/alerts/"
    
    def track_error(self, error, context=None):
        alert_data = {
            "name": f"Application Error: {type(error).__name__}",
            "description": str(error),
            "severity": self._determine_severity(error),
            "tags": ["error", "application", type(error).__name__.lower()],
            "metadata": {
                "error_type": type(error).__name__,
                "traceback": traceback.format_exc(),
                "context": context or {}
            }
        }
        
        if self.service_id:
            alert_data["service_id"] = self.service_id
        if self.team_id:
            alert_data["team_id"] = self.team_id
            
        try:
            response = requests.post(
                self.api_url,
                headers={
                    "X-API-Key": self.api_key,
                    "Content-Type": "application/json"
                },
                json=alert_data,
                timeout=5
            )
            return response.status_code == 200
        except Exception as e:
            print(f"Failed to send error to Warrn: {e}")
            return False
    
    def _determine_severity(self, error):
        # Customize based on error types
        critical_errors = (SystemExit, KeyboardInterrupt, MemoryError)
        high_errors = (ConnectionError, TimeoutError, FileNotFoundError)
        
        if isinstance(error, critical_errors):
            return "critical"
        elif isinstance(error, high_errors):
            return "high"
        else:
            return "medium"

# Usage decorator
def track_errors(tracker):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                tracker.track_error(e, {
                    "function": func.__name__,
                    "args": str(args),
                    "kwargs": str(kwargs)
                })
                raise
        return wrapper
    return decorator

# Example usage
tracker = WarrnErrorTracker(
    api_key="warrn_your_api_key_here",
    service_id="550e8400-e29b-41d4-a716-446655440000"
)

@track_errors(tracker)
def risky_function():
    # Your application code
    raise ValueError("Something went wrong!")