冪等性
冪等な処理のために、イベントのid とリソースの resourceId を利用します。
const processedEvents = new Set();
function processEvent(event) {
// Deduplicate by event ID
if (processedEvents.has(event.id)) {
return;
}
// Process the event
handleEvent(event);
processedEvents.add(event.id);
}
processed_events = set()
def process_event(event):
# Deduplicate by event ID
if event['id'] in processed_events:
return
# Process the event
handle_event(event)
processed_events.add(event['id'])
var processedEvents = make(map[string]bool)
func processEvent(event WebhookEvent) {
// Deduplicate by event ID
if processedEvents[event.ID] {
return
}
// Process the event
handleEvent(event)
processedEvents[event.ID] = true
}
@Service
class WebhookService {
private val processedEvents = mutableSetOf<String>()
fun processEvent(event: WebhookEvent) {
// Deduplicate by event ID
if (event.id in processedEvents) {
return
}
// Process the event
handleEvent(event)
processedEvents.add(event.id)
}
}
エラーハンドリング
常に適切な HTTP ステータスコードを返してください。app.post('/ja/developers/webhooks/tiro', (req, res) => {
try {
const event = req.body;
// Process the event
processEvent(event);
res.status(200).send('OK');
} catch (error) {
console.error('Webhook processing error:', error);
res.status(500).send('Internal server error');
}
});
from flask import Flask, request, jsonify
@app.route('/ja/developers/webhooks/tiro', methods=['POST'])
def handle_webhook():
try:
event = request.get_json()
# Process the event
process_event(event)
return '', 200
except Exception as error:
print(f'Webhook processing error: {error}')
return 'Internal server error', 500
func handleWebhook(w http.ResponseWriter, r *http.Request) {
var event WebhookEvent
if err := json.NewDecoder(r.Body).Decode(&event); err != nil {
http.Error(w, "Bad request", http.StatusBadRequest)
return
}
// Process the event
if err := processEvent(event); err != nil {
log.Printf("Webhook processing error: %v", err)
http.Error(w, "Internal server error", http.StatusInternalServerError)
return
}
w.WriteHeader(http.StatusOK)
}
@RestController
class WebhookController {
@PostMapping("/ja/developers/webhooks/tiro")
fun handleWebhook(@RequestBody event: WebhookEvent): ResponseEntity<String> {
return try {
// Process the event
processEvent(event)
ResponseEntity.ok("OK")
} catch (error: Exception) {
logger.error("Webhook processing error", error)
ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body("Internal server error")
}
}
}
リトライの処理
Tiro の webhook システムは、配信に失敗した場合にリトライを行います。リトライは適切に処理してください。- 処理に成功した場合は 2xx ステータスコードを返す
- 恒久的な失敗の場合は 4xx ステータスコードを返す（リトライは行いません）
- 一時的な失敗の場合は 5xx ステータスコードを返す（リトライを行います）
セキュリティ
常に webhook の真正性を検証してください。function verifyWebhookAuth(authHeader, expectedSecret) {
const token = authHeader.replace('Bearer ', '');
return token === expectedSecret;
}
app.post('/ja/developers/webhooks/tiro', (req, res) => {
const authHeader = req.headers.authorization;
if (!verifyWebhookAuth(authHeader, process.env.WEBHOOK_SECRET)) {
return res.status(401).send('Unauthorized');
}
// Process webhook event
processEvent(req.body);
res.status(200).send('OK');
});
import os
def verify_webhook_auth(auth_header, expected_secret):
if not auth_header or not auth_header.startswith('Bearer '):
return False
token = auth_header.replace('Bearer ', '')
return token == expected_secret
@app.route('/ja/developers/webhooks/tiro', methods=['POST'])
def handle_webhook():
auth_header = request.headers.get('Authorization')
if not verify_webhook_auth(auth_header, os.getenv('WEBHOOK_SECRET')):
return 'Unauthorized', 401
# Process webhook event
event = request.get_json()
process_event(event)
return 'OK', 200
import (
"os"
"strings"
)
func verifyWebhookAuth(authHeader, expectedSecret string) bool {
if !strings.HasPrefix(authHeader, "Bearer ") {
return false
}
token := strings.TrimPrefix(authHeader, "Bearer ")
return token == expectedSecret
}
func handleWebhook(w http.ResponseWriter, r *http.Request) {
authHeader := r.Header.Get("Authorization")
if !verifyWebhookAuth(authHeader, os.Getenv("WEBHOOK_SECRET")) {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
// Process webhook event
var event WebhookEvent
json.NewDecoder(r.Body).Decode(&event)
processEvent(event)
w.WriteHeader(http.StatusOK)
}
@RestController
class WebhookController {
@Value("\${webhook.secret}")
private lateinit var webhookSecret: String
private fun verifyWebhookAuth(authHeader: String?, expectedSecret: String): Boolean {
if (authHeader?.startsWith("Bearer ") != true) {
return false
}
val token = authHeader.removePrefix("Bearer ")
return token == expectedSecret
}
@PostMapping("/ja/developers/webhooks/tiro")
fun handleWebhook(
@RequestHeader("Authorization") authHeader: String?,
@RequestBody event: WebhookEvent
): ResponseEntity<String> {
if (!verifyWebhookAuth(authHeader, webhookSecret)) {
return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body("Unauthorized")
}
// Process webhook event
processEvent(event)
return ResponseEntity.ok("OK")
}
}
リソースのルーティング
効率的なルーティングのために、resourceType と resourceId を利用します。
function routeEvent(event) {
const { resourceType, resourceId } = event.data;
switch (resourceType) {
case 'Note':
return handleNoteEvent(event.type, resourceId, event.data.resource);
case 'NoteDocument':
return handleNoteDocumentEvent(event.type, resourceId, event.data.resource);
case 'NoteSummary':
return handleNoteSummaryEvent(event.type, resourceId, event.data.resource);
case 'FolderNoteRelation':
return handleFolderNoteEvent(event.type, resourceId, event.data.resource);
default:
console.log('Unknown resource type:', resourceType);
}
}