PayPal Webhook API - 웹훅 API

{
  "url": "https://example.com/example_webhook",
  "event_types": [
    {
      "name": "PAYMENT.AUTHORIZATION.CREATED"
    },
    {
      "name": "PAYMENT.AUTHORIZATION.VOIDED"
    }
  ]
}

{
  "id": "0EH40505U7160970P",
  "url": "https://example.com/example_webhook",
  "event_types": [
    {
      "name": "PAYMENT.AUTHORIZATION.CREATED",
      "description": "결제 승인이 생성되었습니다."
    },
    {
      "name": "PAYMENT.AUTHORIZATION.VOIDED",
      "description": "결제 승인이 무효화되었습니다."
    }
  ],
  "links": [
    {
      "href": "https://api-m.paypal.com/v1/notifications/webhooks/0EH40505U7160970P",
      "rel": "self",
      "method": "GET"
    }
  ]
}

{
  "webhooks": [
    {
      "id": "40Y916089Y8324740",
      "url": "https://example.com/example_webhook",
      "event_types": [
        {
          "name": "PAYMENT.AUTHORIZATION.CREATED",
          "description": "결제 승인이 생성되었습니다."
        }
      ],
      "links": [
        {
          "href": "https://api-m.paypal.com/v1/notifications/webhooks/40Y916089Y8324740",
          "rel": "self",
          "method": "GET"
        }
      ]
    }
  ]
}

{
  "id": "0EH40505U7160970P",
  "url": "https://example.com/example_webhook",
  "event_types": [
    {
      "name": "PAYMENT.AUTHORIZATION.CREATED",
      "description": "결제 승인이 생성되었습니다.",
      "status": "ENABLED"
    },
    {
      "name": "PAYMENT.AUTHORIZATION.VOIDED",
      "description": "결제 승인이 무효화되었습니다.",
      "status": "ENABLED"
    }
  ],
  "links": [
    {
      "href": "https://api-m.paypal.com/v1/notifications/webhooks/0EH40505U7160970P",
      "rel": "self",
      "method": "GET"
    }
  ]
}

[
  {
    "op": "replace",
    "path": "/url",
    "value": "https://example.com/example_webhook_2"
  },
  {
    "op": "replace",
    "path": "/event_types",
    "value": [
      {
        "name": "PAYMENT.SALE.REFUNDED"
      }
    ]
  }
]

{
  "id": "0EH40505U7160970P",
  "url": "https://example.com/example_webhook_2",
  "event_types": [
    {
      "name": "PAYMENT.SALE.REFUNDED",
      "description": "판매 결제가 환불되었습니다."
    }
  ],
  "links": [
    {
      "href": "https://api-m.paypal.com/v1/notifications/webhooks/0EH40505U7160970P",
      "rel": "self",
      "method": "GET"
    }
  ]
}

{
  "event_types": [
    {
      "name": "PAYMENT.AUTHORIZATION.CREATED",
      "description": "결제 승인이 생성되었습니다.",
      "status": "ENABLED"
    },
    {
      "name": "PAYMENT.AUTHORIZATION.VOIDED",
      "description": "결제 승인이 무효화되었습니다.",
      "status": "ENABLED"
    },
    {
      "name": "RISK.DISPUTE.CREATED",
      "description": "거래에 대해 분쟁이 제기되었습니다.",
      "status": "DEPRECATED"
    }
  ]
}

{
  "id": "0EH40505U7160970P",
  "client_id": "ASknfhB5DtpICIHI7ZRvVStLDqVIg6mc_ETGcxjtEQkkgHrUU8IOLPUQFTq_",
  "links": [
    {
      "href": "https://api-m.paypal.com/v1/notifications/webhooks-lookup/0EH40505U7160970P",
      "rel": "self",
      "method": "GET"
    }
  ]
}

{
  "id": "0EH40505U7160970P",
  "client_id": "ASknfhB5DtpICIHI7ZRvVStLDqVIg6mc_ETGcxjtEQkkgHrUU8IOLPUQFTq_",
  "account_number": "654839282",
  "links": [
    {
      "href": "https://api-m.paypal.com/v1/notifications/webhooks-lookup/0EH40505U7160970P",
      "rel": "self",
      "method": "GET"
    }
  ]
}

{
  "transmission_id": "69cd13f0-d67a-11e5-baa3-778b53f4dc41",
  "cert_id": "69cd13f0-d67a-11e5-baa3-778b53f4dc42",
  "auth_algo": "SHA256withRSA",
  "transmission_time": "2016-02-18T20:01:35Z",
  "webhook_id": "1JE434234637435435",
  "webhook_event": {
    "id": "8PT597110X687430LKGECATA",
    "create_time": "2013-06-25T21:41:28Z",
    "resource_type": "authorization",
    "event_type": "PAYMENT.AUTHORIZATION.CREATED",
    "summary": "결제 승인이 생성되었습니다",
    "resource": {
      "id": "2DC87612EK520411B",
      "create_time": "2013-06-25T21:39:15Z",
      "update_time": "2013-06-25T21:39:17Z",
      "state": "authorized",
      "amount": {
        "total": "7.47",
        "currency": "USD"
      }
    }
  }
}

{
  "verification_status": "SUCCESS"
}

{
  "event_types": [
    {
      "name": "PAYMENT.AUTHORIZATION.CREATED",
      "description": "결제 승인이 생성되었습니다."
    },
    {
      "name": "PAYMENT.AUTHORIZATION.VOIDED",
      "description": "결제 승인이 무효화되었습니다."
    },
    {
      "name": "PAYMENT.CAPTURE.COMPLETED",
      "description": "결제 수집이 완료되었습니다."
    }
  ]
}

{
  "url": "https://example.com/example_webhook",
  "event_type": "PAYMENT.SALE.COMPLETED"
}

{
  "id": "WH-6RH64098EX891111R-7HV95734TV988632V",
  "event_version": "1.0",
  "create_time": "2018-08-17T21:41:28.032Z",
  "resource_type": "sale",
  "resource_version": "2.0",
  "event_type": "PAYMENT.SALE.COMPLETED",
  "summary": "결제가 완료되었습니다",
  "resource": {
    "id": "5O190127TN364715T",
    "state": "completed",
    "amount": {
      "total": "20.00",
      "currency": "USD"
    },
    "parent_payment": "PAY-17S8410768582940NKEE66EQ",
    "create_time": "2018-08-17T21:39:15Z",
    "update_time": "2018-08-17T21:39:17Z"
  },
  "links": [
    {
      "href": "https://api-m.paypal.com/v1/notifications/webhooks-events/WH-6RH64098EX891111R-7HV95734TV988632V",
      "rel": "self",
      "method": "GET"
    }
  ]
}

PayPal Webhook 
    ↓
Load Balancer (nginx/AWS ALB)
    ↓
Webhook Receiver Service
    ↓
Message Queue (Redis/RabbitMQ/AWS SQS)
    ↓
Webhook Processor Workers
    ↓
Database & Business Logic
    ↓
Notification Service

const express = require('express');
const crypto = require('crypto');
const Redis = require('redis');
 
const app = express();
const redis = Redis.createClient();
 
// 웹훅 수신 엔드포인트
app.post('/webhook/paypal', express.raw({type: 'application/json'}), async (req, res) => {
    try {
        // 1. 서명 검증
        const isValidSignature = await verifyWebhookSignature(req);
        if (!isValidSignature) {
            return res.status(401).json({ error: 'Invalid signature' });
        }
 
        // 2. 웹훅 데이터 파싱
        const webhookEvent = JSON.parse(req.body);
        const eventId = webhookEvent.id;
        const eventType = webhookEvent.event_type;
 
        // 3. 중복 체크 (멱등성 보장)
        const isDuplicate = await redis.exists(`webhook:${eventId}`);
        if (isDuplicate) {
            console.log(`Duplicate webhook event: ${eventId}`);
            return res.status(200).json({ status: 'processed' });
        }
 
        // 4. 이벤트 큐에 추가
        await redis.lpush('webhook_queue', JSON.stringify({
            eventId,
            eventType,
            data: webhookEvent,
            receivedAt: new Date().toISOString()
        }));
 
        // 5. 중복 방지를 위한 이벤트 ID 저장 (24시간 TTL)
        await redis.setex(`webhook:${eventId}`, 86400, 'processed');
 
        // 6. 즉시 응답
        res.status(200).json({ status: 'received' });
 
        // 7. 로깅
        console.log(`Webhook received: ${eventType} - ${eventId}`);
 
    } catch (error) {
        console.error('Webhook processing error:', error);
        res.status(500).json({ error: 'Internal server error' });
    }
});
 
// 서명 검증 함수
async function verifyWebhookSignature(req) {
    const headers = req.headers;
    const transmissionId = headers['paypal-transmission-id'];
    const certId = headers['paypal-cert-id'];
    const authAlgo = headers['paypal-auth-algo'];
    const transmissionTime = headers['paypal-transmission-time'];
    const webhookId = process.env.PAYPAL_WEBHOOK_ID;
    
    try {
        const response = await fetch('https://api-m.sandbox.paypal.com/v1/notifications/verify-webhook-signature', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${await getAccessToken()}`
            },
            body: JSON.stringify({
                transmission_id: transmissionId,
                cert_id: certId,
                auth_algo: authAlgo,
                transmission_time: transmissionTime,
                webhook_id: webhookId,
                webhook_event: JSON.parse(req.body)
            })
        });
 
        const result = await response.json();
        return result.verification_status === 'SUCCESS';
    } catch (error) {
        console.error('Signature verification error:', error);
        return false;
    }
}

const Redis = require('redis');
const redis = Redis.createClient();
 
class WebhookProcessor {
    constructor() {
        this.handlers = new Map();
        this.setupHandlers();
    }
 
    setupHandlers() {
        // 결제 관련 핸들러
        this.handlers.set('PAYMENT.SALE.COMPLETED', this.handlePaymentCompleted.bind(this));
        this.handlers.set('PAYMENT.SALE.REFUNDED', this.handlePaymentRefunded.bind(this));
        this.handlers.set('PAYMENT.CAPTURE.COMPLETED', this.handleCaptureCompleted.bind(this));
        
        // 구독 관련 핸들러
        this.handlers.set('BILLING.SUBSCRIPTION.CREATED', this.handleSubscriptionCreated.bind(this));
        this.handlers.set('BILLING.SUBSCRIPTION.ACTIVATED', this.handleSubscriptionActivated.bind(this));
        this.handlers.set('BILLING.SUBSCRIPTION.CANCELLED', this.handleSubscriptionCancelled.bind(this));
        this.handlers.set('BILLING.SUBSCRIPTION.PAYMENT.FAILED', this.handleSubscriptionPaymentFailed.bind(this));
        
        // 분쟁 관련 핸들러
        this.handlers.set('CUSTOMER.DISPUTE.CREATED', this.handleDisputeCreated.bind(this));
        this.handlers.set('CUSTOMER.DISPUTE.RESOLVED', this.handleDisputeResolved.bind(this));
    }
 
    async start() {
        console.log('Webhook processor started');
        
        while (true) {
            try {
                // 큐에서 웹훅 이벤트 가져오기
                const eventData = await redis.brpop('webhook_queue', 10);
                
                if (eventData) {
                    const webhookEvent = JSON.parse(eventData[1]);
                    await this.processEvent(webhookEvent);
                }
            } catch (error) {
                console.error('Worker error:', error);
                await new Promise(resolve => setTimeout(resolve, 5000)); // 5초 대기
            }
        }
    }
 
    async processEvent(webhookEvent) {
        const { eventId, eventType, data } = webhookEvent;
        
        try {
            console.log(`Processing webhook: ${eventType} - ${eventId}`);
            
            const handler = this.handlers.get(eventType);
            if (handler) {
                await handler(data);
                console.log(`Successfully processed: ${eventType} - ${eventId}`);
            } else {
                console.log(`No handler for event type: ${eventType}`);
            }
            
        } catch (error) {
            console.error(`Error processing webhook ${eventId}:`, error);
            
            // 실패한 이벤트를 DLQ(Dead Letter Queue)로 이동
            await redis.lpush('webhook_dlq', JSON.stringify({
                ...webhookEvent,
                error: error.message,
                failedAt: new Date().toISOString()
            }));
        }
    }
 
    // 결제 완료 핸들러
    async handlePaymentCompleted(webhookData) {
        const payment = webhookData.resource;
        const paymentId = payment.id;
        const amount = payment.amount.total;
        const currency = payment.amount.currency;
        
        // 데이터베이스 업데이트
        await db.query(`
            UPDATE payments 
            SET status = 'completed', 
                completed_at = NOW(),
                amount = ?,
                currency = ?
            WHERE paypal_payment_id = ?
        `, [amount, currency, paymentId]);
        
        // 사용자에게 알림 발송
        await sendPaymentConfirmationEmail(payment);
        
        // 서비스 활성화 (구독 등)
        await activateUserService(payment);
    }
 
    // 구독 생성 핸들러
    async handleSubscriptionCreated(webhookData) {
        const subscription = webhookData.resource;
        const subscriptionId = subscription.id;
        const planId = subscription.plan_id;
        
        // 구독 정보 저장
        await db.query(`
            INSERT INTO subscriptions (
                paypal_subscription_id, 
                plan_id, 
                status, 
                created_at
            ) VALUES (?, ?, 'CREATED', NOW())
        `, [subscriptionId, planId]);
        
        console.log(`Subscription created: ${subscriptionId}`);
    }
 
    // 구독 결제 실패 핸들러
    async handleSubscriptionPaymentFailed(webhookData) {
        const subscription = webhookData.resource;
        const subscriptionId = subscription.id;
        
        // 구독 상태 업데이트
        await db.query(`
            UPDATE subscriptions 
            SET status = 'PAYMENT_FAILED',
                last_payment_failed_at = NOW()
            WHERE paypal_subscription_id = ?
        `, [subscriptionId]);
        
        // 사용자에게 결제 실패 알림
        await sendPaymentFailureNotification(subscription);
        
        // 재시도 스케줄링
        await schedulePaymentRetry(subscriptionId);
    }
 
    // 분쟁 생성 핸들러
    async handleDisputeCreated(webhookData) {
        const dispute = webhookData.resource;
        const disputeId = dispute.dispute_id;
        const transactionId = dispute.disputed_transactions[0].seller_transaction_id;
        
        // 분쟁 정보 저장
        await db.query(`
            INSERT INTO disputes (
                paypal_dispute_id,
                transaction_id,
                status,
                amount,
                currency,
                reason,
                created_at
            ) VALUES (?, ?, ?, ?, ?, ?, NOW())
        `, [
            disputeId,
            transactionId,
            dispute.status,
            dispute.amount.value,
            dispute.amount.currency_code,
            dispute.reason
        ]);
        
        // 관리자에게 알림
        await sendDisputeAlert(dispute);
    }
}
 
// 워커 실행
const processor = new WebhookProcessor();
processor.start();

-- 웹훅 이벤트 로그 테이블
CREATE TABLE webhook_events (
    id SERIAL PRIMARY KEY,
    event_id VARCHAR(100) UNIQUE NOT NULL,
    event_type VARCHAR(100) NOT NULL,
    event_version VARCHAR(20),
    resource_type VARCHAR(50),
    status VARCHAR(20) DEFAULT 'RECEIVED',
    payload JSONB,
    processed_at TIMESTAMP,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    
    INDEX idx_event_type (event_type),
    INDEX idx_event_id (event_id),
    INDEX idx_created_at (created_at)
);
 
-- 결제 테이블
CREATE TABLE payments (
    id SERIAL PRIMARY KEY,
    paypal_payment_id VARCHAR(50) UNIQUE,
    user_id INTEGER REFERENCES users(id),
    amount DECIMAL(10,2),
    currency VARCHAR(3),
    status VARCHAR(20) DEFAULT 'PENDING',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    completed_at TIMESTAMP,
    
    INDEX idx_paypal_payment_id (paypal_payment_id),
    INDEX idx_user_id (user_id),
    INDEX idx_status (status)
);
 
-- 구독 테이블
CREATE TABLE subscriptions (
    id SERIAL PRIMARY KEY,
    paypal_subscription_id VARCHAR(50) UNIQUE,
    user_id INTEGER REFERENCES users(id),
    plan_id VARCHAR(50),
    status VARCHAR(20) DEFAULT 'PENDING',
    next_billing_time TIMESTAMP,
    last_payment_failed_at TIMESTAMP,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    
    INDEX idx_paypal_subscription_id (paypal_subscription_id),
    INDEX idx_user_id (user_id),
    INDEX idx_status (status)
);
 
-- 분쟁 테이블
CREATE TABLE disputes (
    id SERIAL PRIMARY KEY,
    paypal_dispute_id VARCHAR(50) UNIQUE,
    transaction_id VARCHAR(50),
    user_id INTEGER REFERENCES users(id),
    amount DECIMAL(10,2),
    currency VARCHAR(3),
    status VARCHAR(20),
    reason VARCHAR(100),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    resolved_at TIMESTAMP,
    
    INDEX idx_paypal_dispute_id (paypal_dispute_id),
    INDEX idx_transaction_id (transaction_id),
    INDEX idx_status (status)
);
 
-- 실패한 웹훅 처리 테이블
CREATE TABLE webhook_failures (
    id SERIAL PRIMARY KEY,
    event_id VARCHAR(100),
    event_type VARCHAR(100),
    error_message TEXT,
    retry_count INTEGER DEFAULT 0,
    max_retries INTEGER DEFAULT 3,
    next_retry_at TIMESTAMP,
    payload JSONB,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    
    INDEX idx_event_id (event_id),
    INDEX idx_next_retry_at (next_retry_at)
);

// Prometheus 메트릭 예시
const promClient = require('prom-client');
 
const webhookCounter = new promClient.Counter({
    name: 'paypal_webhooks_received_total',
    help: 'Total number of PayPal webhooks received',
    labelNames: ['event_type', 'status']
});
 
const webhookProcessingDuration = new promClient.Histogram({
    name: 'paypal_webhook_processing_duration_seconds',
    help: 'Duration of webhook processing',
    labelNames: ['event_type']
});
 
const webhookQueueSize = new promClient.Gauge({
    name: 'paypal_webhook_queue_size',
    help: 'Current size of webhook processing queue'
});
 
// 웹훅 수신시 메트릭 업데이트
function recordWebhookReceived(eventType, status) {
    webhookCounter.labels(eventType, status).inc();
}
 
function recordProcessingTime(eventType, duration) {
    webhookProcessingDuration.labels(eventType).observe(duration);
}

// Slack 알림 예시
async function sendSlackAlert(message, severity = 'warning') {
    const webhook_url = process.env.SLACK_WEBHOOK_URL;
    
    const payload = {
        text: `PayPal Webhook Alert`,
        attachments: [{
            color: severity === 'error' ? 'danger' : 'warning',
            text: message,
            ts: Math.floor(Date.now() / 1000)
        }]
    };
    
    await fetch(webhook_url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload)
    });
}
 
// 웹훅 처리 실패 시 알림
async function alertWebhookFailure(eventId, eventType, error) {
    const message = `웹훅 처리 실패\n이벤트 ID: ${eventId}\n이벤트 타입: ${eventType}\n오류: ${error}`;
    await sendSlackAlert(message, 'error');
}
 
// 큐 크기 모니터링
setInterval(async () => {
    const queueSize = await redis.llen('webhook_queue');
    webhookQueueSize.set(queueSize);
    
    if (queueSize > 1000) {
        await sendSlackAlert(`웹훅 큐 크기 경고: ${queueSize}개 대기중`, 'warning');
    }
}, 60000); // 1분마다 체크

class RetryManager {
    constructor() {
        this.maxRetries = 5;
        this.baseDelay = 1000; // 1초
    }
 
    async processWithRetry(eventData, handler) {
        let lastError;
        
        for (let attempt = 0; attempt < this.maxRetries; attempt++) {
            try {
                await handler(eventData);
                return; // 성공시 종료
            } catch (error) {
                lastError = error;
                console.log(`Attempt ${attempt + 1} failed:`, error.message);
                
                if (attempt < this.maxRetries - 1) {
                    const delay = this.calculateDelay(attempt);
                    await this.sleep(delay);
                }
            }
        }
        
        // 모든 재시도 실패
        throw new Error(`Max retries exceeded. Last error: ${lastError.message}`);
    }
 
    calculateDelay(attempt) {
        // 지수 백오프: 1초, 2초, 4초, 8초, 16초
        return this.baseDelay * Math.pow(2, attempt);
    }
 
    sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }
}
 
// 사용 예시
const retryManager = new RetryManager();
 
async function processWebhookWithRetry(webhookEvent) {
    try {
        await retryManager.processWithRetry(webhookEvent, async (event) => {
            const handler = this.handlers.get(event.eventType);
            if (handler) {
                await handler(event.data);
            }
        });
    } catch (error) {
        // DLQ로 이동
        await redis.lpush('webhook_dlq', JSON.stringify({
            ...webhookEvent,
            finalError: error.message,
            maxRetriesExceeded: true,
            failedAt: new Date().toISOString()
        }));
    }
}

// PayPal IP 주소 범위 (예시 - 실제로는 PayPal 문서 확인 필요)
const paypalIpRanges = [
    '173.0.84.0/24',
    '173.0.82.0/24',
    '216.113.188.0/24'
    // PayPal에서 제공하는 실제 IP 범위 추가
];
 
function isPayPalIP(clientIP) {
    return paypalIpRanges.some(range => {
        return ipRangeCheck(clientIP, range);
    });
}
 
// 미들웨어로 IP 체크
app.use('/webhook/paypal', (req, res, next) => {
    const clientIP = req.ip || req.connection.remoteAddress;
    
    if (!isPayPalIP(clientIP)) {
        console.log(`Blocked request from unauthorized IP: ${clientIP}`);
        return res.status(403).json({ error: 'Forbidden' });
    }
    
    next();
});

const rateLimit = require('express-rate-limit');
 
const webhookLimiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15분
    max: 1000, // 최대 1000개 요청
    message: 'Too many webhook requests',
    standardHeaders: true,
    legacyHeaders: false
});
 
app.use('/webhook/paypal', webhookLimiter);

// Jest 테스트 예시
describe('WebhookProcessor', () => {
    let processor;
    
    beforeEach(() => {
        processor = new WebhookProcessor();
    });
 
    test('should handle payment completed event', async () => {
        const mockWebhookData = {
            id: 'WH-123',
            event_type: 'PAYMENT.SALE.COMPLETED',
            resource: {
                id: 'PAY-123',
                amount: { total: '10.00', currency: 'USD' },
                state: 'completed'
            }
        };
 
        const mockHandler = jest.fn();
        processor.handlers.set('PAYMENT.SALE.COMPLETED', mockHandler);
        
        await processor.processEvent({
            eventId: 'WH-123',
            eventType: 'PAYMENT.SALE.COMPLETED',
            data: mockWebhookData
        });
 
        expect(mockHandler).toHaveBeenCalledWith(mockWebhookData);
    });
 
    test('should handle unknown event type gracefully', async () => {
        const consoleSpy = jest.spyOn(console, 'log');
        
        await processor.processEvent({
            eventId: 'WH-123',
            eventType: 'UNKNOWN.EVENT.TYPE',
            data: {}
        });
 
        expect(consoleSpy).toHaveBeenCalledWith('No handler for event type: UNKNOWN.EVENT.TYPE');
    });
});

// PayPal 웹훅 시뮬레이터를 사용한 통합 테스트
describe('Webhook Integration Tests', () => {
    test('should receive and process webhook from PayPal simulator', async () => {
        // PayPal 시뮬레이터에서 웹훅 발송
        const response = await fetch('https://api-m.sandbox.paypal.com/v1/notifications/simulate-event', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${accessToken}`
            },
            body: JSON.stringify({
                url: 'https://your-test-server.com/webhook/paypal',
                event_type: 'PAYMENT.SALE.COMPLETED'
            })
        });
 
        expect(response.status).toBe(202);
 
        // 웹훅 처리 확인 (비동기이므로 잠시 대기)
        await new Promise(resolve => setTimeout(resolve, 5000));
        
        const processedEvent = await redis.get('test:webhook:processed');
        expect(processedEvent).toBeTruthy();
    });
});

// Express 대시보드 예시
app.get('/admin/webhooks/dashboard', async (req, res) => {
    const stats = {
        totalReceived: await redis.get('stats:webhooks:total') || 0,
        todayReceived: await redis.get(`stats:webhooks:${today}`) || 0,
        queueSize: await redis.llen('webhook_queue'),
        dlqSize: await redis.llen('webhook_dlq'),
        recentEvents: await getRecentWebhookEvents(10)
    };
    
    res.render('webhook-dashboard', { stats });
});
 
// 웹훅 재처리 API
app.post('/admin/webhooks/:eventId/retry', async (req, res) => {
    const { eventId } = req.params;
    
    try {
        const eventData = await db.query('SELECT * FROM webhook_events WHERE event_id = ?', [eventId]);
        if (eventData.length === 0) {
            return res.status(404).json({ error: 'Event not found' });
        }
        
        // 큐에 다시 추가
        await redis.lpush('webhook_queue', JSON.stringify(eventData[0]));
        
        res.json({ status: 'retry scheduled' });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// 배치 처리를 통한 성능 최적화
class BatchWebhookProcessor {
    constructor() {
        this.batchSize = 10;
        this.batchTimeout = 5000; // 5초
    }
 
    async startBatchProcessing() {
        while (true) {
            try {
                const events = await this.getBatchEvents();
                if (events.length > 0) {
                    await this.processBatch(events);
                }
            } catch (error) {
                console.error('Batch processing error:', error);
            }
        }
    }
 
    async getBatchEvents() {
        const events = [];
        const startTime = Date.now();
        
        while (events.length < this.batchSize && 
               (Date.now() - startTime) < this.batchTimeout) {
            
            const event = await redis.brpop('webhook_queue', 1);
            if (event) {
                events.push(JSON.parse(event[1]));
            }
        }
        
        return events;
    }
 
    async processBatch(events) {
        const promises = events.map(event => this.processEvent(event));
        await Promise.allSettled(promises);
    }
}