Events

Events let you build event-driven architecture between your services through a unified interface. Declare a broker (the connection to your message provider), define topics on it, then produce and consume from anywhere in your stack.

SDK naming

The events API is exposed as ductape.events in the SDK.

Quick example

TypeScript

import Ductape from '@ductape/sdk';

const ductape = new Ductape({ accessKey: 'your-access-key' });

// Produce
await ductape.events.produce({
  event: 'order-events:order-created',
  message: { orderId: '123', total: 99.99 },
});

// Consume
await ductape.events.consume({
  event: 'order-events:order-created',
  callback: async (message) => {
    await processOrder(message);
  },
});

Java

import app.ductape.sdk.Ductape;
import app.ductape.sdk.core.EnvType;
import app.ductape.sdk.core.RequestContext;

RequestContext auth = new RequestContext(null, null, null, null, 'your-access-key' );
Ductape ductape = new Ductape(EnvType.PRODUCTION, auth);

// Produce
ductape.events.produce(Map.of(
  "event", "order-events:order-created",
  message: Map.of( "orderId", "123", "total", 99.99 )
));

// Consume
ductape.events.consume(Map.of(
  "event", "order-events:order-created",
  callback: async (message) => Map.of(
    processOrder(message);
  )
));

Go

import (
	"context"
	"github.com/ductape/ductape/sdk/go/core"
	ductapesdk "github.com/ductape/ductape/sdk/go/ductape"
)

auth := core.NewRequestContext("", "", "", "", 'your-access-key' )
client, err := ductapesdk.New(core.EnvProduction, auth)
if err != nil {
	return err
}

// Produce
client.events.produce({
  "event": "order-events:order-created",
  message: { "orderId": "123", "total": 99.99 },
});

// Consume
client.events.consume({
  "event": "order-events:order-created",
  callback: async (message) => {
    processOrder(message);
  },
});

.NET

using Ductape.Sdk;
using Ductape.Sdk.Core;

var auth = new RequestContext(null, null, null, null, 'your-access-key' , null);
var ductape = new Ductape(EnvType.Production, auth);

// Produce
await ductape.events.produce({
  ["event"] = "order-events:order-created",
  message: { ["orderId"] = "123", ["total"] = 99.99 },
});

// Consume
await ductape.events.consume({
  ["event"] = "order-events:order-created",
  callback: async (message) => {
    await processOrder(message);
  },
});

Events use the format brokerTag:topicTag. Everything before the colon identifies the broker; everything after identifies the topic within it.

Three concepts

Concept	What it is
Broker	A connection configuration for one message provider (credentials + per-env settings). Brokers have no topics built in — topics are added separately.
Topic	A named event stream within a broker. One broker supports unlimited topics; each is created via events.topics.create.
Event	A message produced to or consumed from a topic. Always referenced as brokerTag:topicTag.

Supported providers

Provider	Type constant	Best for
Kafka	KAFKA	High-throughput distributed streaming
RabbitMQ	RABBITMQ	Flexible routing, reliable delivery
Redis	REDIS	Simple pub/sub, low latency
AWS SQS	AWS_SQS	Serverless managed queues
Azure Service Bus	AZURE_SERVICE_BUS	Azure managed messaging
Google Pub/Sub	GOOGLE_PUBSUB	GCP integration
NATS	NATS	Lightweight, high-performance messaging

Next steps

• Getting started — set up a broker, define topics, produce and consume
• CLI: ductape apply — declare and sync your broker config from a file