Index of every page on this site: llms.txt
All skills
jeremylongshore avatar

/emitting-api-events

@820dfc8
Run it yourself

Build event-driven APIs with webhooks, Server-Sent Events, and real-time notifications. Use when building event-driven API architectures. Trigger with phrases like "add webhooks", "implement events", or "create event-driven API".

Use this Skill: https://skilld.dev/gh/jeremylongshore/tons-of-skills-marketplace/emitting-api-events

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈63 tokens for metadata: the name and description. ≈1.3k when used: this file. ≈2.1k more on demand in 3 files.

Description uses 3.1% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈251 characters, or 3.1%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Emitting API Events

Overview

Build event-driven API architectures using outbound webhooks, Server-Sent Events (SSE), and message broker integration. Implement event emission from API mutations, event schema registry, subscriber management, delivery guarantees with retry logic, and event sourcing patterns for maintaining a complete audit log of API state changes.

Prerequisites

  • Message broker: Redis Pub/Sub, RabbitMQ, Apache Kafka, or AWS SNS/SQS
  • Persistent storage for event log and subscriber registrations (PostgreSQL, MongoDB)
  • Webhook delivery infrastructure with retry queue (Bull, Celery, or managed service)
  • Event schema registry for versioned event type definitions
  • SSE-capable web framework for real-time event streaming to browser clients

Instructions

  1. Identify event-producing operations using Grep and Read, cataloging every API mutation (POST, PUT, PATCH, DELETE) that should emit events, with event type names following resource.action convention (e.g., order.created, user.updated).
  2. Define event schemas for each event type with versioning: include eventId (UUID), eventType, version, timestamp (ISO 8601), source (service identifier), and data (type-specific payload).
  3. Implement the event emitter service that publishes events to the message broker after successful API mutations, using the transactional outbox pattern to ensure events are not lost on application crash.
  4. Build a webhook subscription management API: POST /webhooks (subscribe), GET /webhooks (list), DELETE /webhooks/:id (unsubscribe), with URL validation, event type filtering, and signing secret generation.
  5. Implement webhook delivery with HMAC-SHA256 signed payloads, configurable retry policy (exponential backoff: 1min, 5min, 30min, 2hr, 24hr), and automatic subscription deactivation after consecutive failures.
  6. Add Server-Sent Events endpoint (GET /events/stream) for real-time event delivery to browser clients, with Last-Event-ID support for reconnection and missed event replay.
  7. Create a dead-letter queue for events that exhaust all delivery retry attempts, with alerting and manual replay capability.
  8. Write integration tests covering event emission, webhook delivery with signature verification, SSE stream connection with reconnection, and dead-letter queue behavior.

See references/implementation.md for the full implementation guide.

Output

  • ${CLAUDE_SKILL_DIR}/src/events/emitter.js - Event emission service with outbox pattern
  • ${CLAUDE_SKILL_DIR}/src/events/schemas/ - Versioned event type schema definitions
  • ${CLAUDE_SKILL_DIR}/src/events/webhooks/ - Webhook delivery, signing, and retry logic
  • ${CLAUDE_SKILL_DIR}/src/events/sse.js - Server-Sent Events streaming endpoint
  • ${CLAUDE_SKILL_DIR}/src/routes/webhooks.js - Webhook subscription management API
  • ${CLAUDE_SKILL_DIR}/src/events/dead-letter.js - Dead-letter queue handler with replay
  • ${CLAUDE_SKILL_DIR}/tests/events/ - Event emission and delivery integration tests

Error Handling

Error Cause Solution
Event lost on crash Application crashes between database commit and event publish Use transactional outbox pattern: write event to outbox table in same transaction, poll and publish separately
Webhook delivery failure Subscriber endpoint unreachable or returns non-2xx Retry with exponential backoff; deactivate subscription after 5 consecutive failures; notify subscriber admin
Event ordering violation Concurrent mutations publish events out of order Use partition keys (resource ID) for ordered delivery within a partition; accept out-of-order across partitions
SSE connection memory leak Server accumulates stale SSE connections without cleanup Implement heartbeat comments (:keepalive\n\n) every 15 seconds; detect and close dead connections
Schema version mismatch Consumer expects v1 event format but receives v2 Include version field in event envelope; support simultaneous v1/v2 delivery; deprecate old versions with notice

Refer to references/errors.md for comprehensive error patterns.

Examples

Order lifecycle events: Emit order.created, order.payment_received, order.shipped, and order.delivered events with order details, enabling downstream services (warehouse, email, analytics) to react asynchronously.

SSE live notifications: Browser client connects to GET /events/stream?types=message.received,order.updated and receives real-time event updates with automatic reconnection and Last-Event-ID replay on network interruption.

Transactional outbox: Write the event record to an outbox table within the same database transaction as the API mutation, then poll the outbox table every 100ms to publish events to Kafka, ensuring at-least-once delivery.

See references/examples.md for additional examples.

Resources

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts2mo3 checks · Risk SAFE
  • Gen Agent Trust Hub2mo

    The skill provides functionality for building event-driven API components like webhooks and Server-Sent Events. It contains a standard indirect prompt injection surface inherent to its primary purpose of processing and transmitting external data, but no malicious behavior or obfuscation was found.

  • Socket2mo

    No alerts

  • Snyk2mo

    Risk: LOW · No issues

Signed by skilld at 820dfc8. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 20 hours ago.

Activeupdated last month
What it can do
Reads files Edits files Runs commands
version
1.25.0
author
Jeremy Longshore <jeremy@intentsolutions.io>
tags
[
  "api",
  "webhooks",
  "emitting-api"
]
All 6 allowed tools
ReadWriteEditGrepGlobBash(api:events-*)
Other metadata
compatibility
Designed for Claude Code

README badge

README badge for jeremylongshore/tons-of-skills-marketplace/emitting-api-events