Apache Kafka connector
Publish computed Genesys Cloud KPIs to Apache Kafka — self-managed, Confluent Cloud, or any Kafka-compatible cluster. The same operational metrics that feed Power BI and WFM land on your topics as clean, already-correlated events, ready for stream processors, warehouses and ML pipelines.
At a glance
Framework-ready- What it delivers
- A computed KPI event stream on Kafka topics — JSON or Avro with optional Schema Registry contracts.
- Who consumes
- Stream processors, analytics services, warehouse loaders, ML feature pipelines and audit consumers.
- Source path
- Reactive Engine → metrics store → Global.Platform.Kafka producer.
- Built on
- The production-proven Global.Platform.RabbitMq egress pattern.
- Not a replacement for
- Scheduled WFM HTTP feed contracts — those keep interval discipline.
Structural KPIs derived from Genesys topics — plus client-specific metrics — are computed once in the Reactive Engine and shared across all sinks.
Embed ingest, reactive processing and storage on infrastructure you own on Azure, AWS or GCP — or consume it as a managed PaaS bridge.
Sub-second, continuous reactive processing from the live Genesys event stream — no nightly batch windows for streaming sinks.
Each destination ships as a Global.Platform.* package; the Reactive Engine is never rewritten.
Overview
Why Kafka belongs in a Genesys program
Genesys holds the operational truth; Kafka is the nervous system wiring CRM, warehouses, ML and alerting together. The gap is getting trustworthy, consistent KPIs onto the bus without bespoke glue.
Stop hand-building fragile producers
Teams without a Genesys-native Kafka path end up writing custom producers per consumer — each re-parsing Genesys APIs on its own cadence, each drifting the moment routing or skills change, each duplicating correlation logic the Reactive Engine already solved.
- No per-consumer re-parsing of Genesys APIs
- No silent drift when queue or skill config changes
- Correlation logic lives in one engine, not five scripts
One definition, produced once, consumed by everything
Streamvane publishes already-computed KPI envelopes — the exact same semantics as the Power BI and HTTP feed connectors. Service level on a dashboard and service level on a topic are the same number, by construction.
- Identical KPI semantics across every sink
- Keyed envelopes for partition ordering and dedup
- JSON for speed, Avro + Schema Registry for strict contracts
Powered by the Reactive Engine
Every connector is a thin package on one proven core
This connector does not re-implement Genesys integration. It is a focused Global.Platform.* egress package bound to the same Reactive Engine that powers Power BI, operational HTTP feeds and the rest of the catalog. The hard part — correlating the Genesys event stream into trustworthy operational KPIs — is solved once and reused everywhere.
- One ingestion and reactive processing pipeline, many destinations
- Adding a sink is a connector, not a re-architecture
- Consistent KPI semantics across every downstream system
Architecture
How an event becomes a Kafka record
Kafka is just another sink on the same pipeline. Nothing about your KPI definitions changes — only the transport at the end.
Genesys Cloud
Conversations, queues, agents
Service Bus ingress
Durable, ordered events
Reactive Engine
KPI compute & replay
Metrics store
Computed intervals
Kafka producer
Global.Platform.Kafka
Topics & consumers
Analytics · warehouse · ML
Binding point is identical to RabbitMQ — after a reactive processing flush or on a scheduled read from metrics store.
Platform capabilities
The engine guarantees behind every delivery
This connector inherits the correctness, durability and governance of the Reactive Engine — not just a pipe to a destination.
Deterministic reactive processing
The engine computes each KPI from the raw event stream with explicit, reviewable semantics — not opaque aggregates you can't reconcile.
Durable log & replay
An ordered, durable event log lets you recompute, backfill and audit any interval with confidence after a config change.
Idempotent delivery
Keyed envelopes with timestamps let every downstream consumer dedup safely on retry, replay or backfill.
Schema & version governance
Payload contracts are versioned per connector, so consumers upgrade on their own schedule without surprise breakage.
Backpressure & retry
Retry-with-backoff and dead-letter patterns keep transient downstream failures from ever losing a KPI.
Fan-out from one source
Mix real-time streaming and scheduled feeds to many destinations from a single, consistent source of truth.
Integration depth
How deep the integration goes
Integration is a spectrum, not a checkbox. Genesys operational truth is exposed through the Streamvane platform deployed in your Azure — from straightforward egress to a connector embedded in your processing path.
Compute & deliver
The default for most connectors: Genesys operational KPIs are computed once and delivered outward to your destination — streaming or scheduled.
- Read-oriented egress of computed metrics
- Streaming push or scheduled feed cadence
- Same KPI semantics as every other sink
Operational contracts
Schema-controlled, SLA-bound feeds with reconciliation and acceptance criteria — the contract-grade integration WFM and BPO programs depend on.
- Versioned payload schema with acceptance tolerances
- Interval discipline, timezone and latency contracted
- Reconciliation against Genesys source built in
Embedded in your platform
Streamvane is deployed plug-and-play — down to components and code — inside your own cloud subscription on Azure, AWS or GCP, sitting in the Genesys processing path. Genesys operational truth is exposed through our offering, not a brittle hand-built API scrape that drifts on every routing change. Prefer not to operate it? Run the same engine as a managed PaaS bridge instead.
- Deployed into your event mesh and data plane, on Azure, AWS or GCP
- Plug-and-play components, or fully managed as a PaaS
- Extensible with new Global.Platform.* packages
Security
Your data, your tenant, your keys
Security isn't an afterthought bolted onto an export — it's the architecture. Genesys operational data is processed and stored inside your own Azure subscription, under your governance.
Client-owned cloud & data residency
When embedded, Genesys data is ingested, computed and stored inside your own subscription and region — on Azure, AWS or GCP — never transiting or resting in a vendor-controlled cloud.
Encryption in transit & at rest
TLS 1.2+ to every endpoint and Azure storage encryption at rest, with customer-managed keys where your policy requires them.
Secrets in Key Vault, no creds in code
Connection strings, tokens and certificates live in your Key Vault and are read with Managed Identity — never embedded in configuration or source.
RBAC & least privilege
Every component runs with scoped Azure RBAC roles and the minimum permissions needed for its sink — auditable and reviewable.
Network isolation
Private endpoints, VNet integration and IP allow-listing or mTLS keep traffic on private paths where downstream security requires it.
Audit & observability
Diagnostic logs and Application Insights give you a full audit trail of what was produced, when, and to which destination.
DevOps & SecOps
Built to live in your software lifecycle
The connector is engineered, versioned and operated like any other service in your estate — provisioned as code, shipped through your pipelines, governed by your release process.
Infrastructure as Code
The whole footprint — Service Bus, the metrics store, Key Vault, workers and the connector — is provisioned from Bicep or Terraform you can review and own.
CI/CD pipelines
Build, test and deploy through your Azure DevOps or GitHub Actions pipelines, with the connector versioned like any other service.
Environment promotion
Dev, test and production parity with config-driven KPI profiles, so a feed proven in test promotes cleanly to production.
Config & secrets management
KPI profiles, schedules and endpoints are configuration — managed in App Configuration and Key Vault, not hard-coded redeploys.
Observability & SLOs
Health, lag and throughput are surfaced as metrics and alerts so operations teams trust the numbers and catch drift early.
Security in the pipeline (SecOps)
Dependency and static analysis run in the pipeline, with change control and SecOps gates aligned to your release process.
Technical reference
The details engineers will ask for
What gets decided in discovery and what delivery actually involves.
Topic & schema design
Decided once, in discovery, with the teams that own the consumers. Sensible defaults, no surprises.
| Decision | Typical approach |
|---|---|
| Topics | Per KPI family (genesys.agent-state, genesys.queue-metrics) or tenant-consolidated |
| Keys | queueId, skillId or agentId — enables partition ordering |
| Value | JSON envelope matching the reactive processing KPI contract |
| Schema Registry | Optional Avro for strict, versioned consumer contracts |
| Compaction | Disabled for time-series metrics; enabled for latest-state topics |
Kafka or Azure Event Hubs?
Both run on the same Reactive Engine and share producer logic — the choice is about the estate you already operate.
| Self-managed / Confluent Kafka | Azure Event Hubs | |
|---|---|---|
| Estate | Multi-cloud, existing Kafka operations | Azure-first |
| API | Native Kafka protocol | Kafka-compatible endpoint |
| Connector package | Global.Platform.Kafka | Global.Platform.EventHubs |
| Best when | You already run Kafka or Confluent | Your platform is Azure-native |
What delivery actually involves
This is not a greenfield Genesys integration. The hard part — the Reactive Engine — already exists and runs in production.
| Component | Effort | Why |
|---|---|---|
| Platform producer package | Small | Mirrors the proven Global.Platform.RabbitMq egress |
| KPI mapper | Medium | Reuses existing reactive processing models |
| Discovery & acceptance | Medium | Topic and schema sign-off with consuming teams |
Typical path to a working pilot topic is measured in weeks, not the quarters a bespoke Genesys-to-Kafka build would take.
Frequently asked
Is the stream real-time?
KPIs are produced continuously as the Reactive Engine flushes intervals — typically reaching topics within seconds. Scheduled reads from metrics store are also supported where consumers prefer fixed cadences.
Do you support Avro and Schema Registry?
Yes. JSON is the default for fast onboarding; Avro with a Schema Registry is enabled when consumers require strict, versioned contracts.
Self-managed Kafka or Confluent Cloud?
Both, plus any Kafka-compatible cluster. Connectivity and authentication differ only by configuration resolved from Key Vault.
How do you secure the connection to our cluster?
SASL / SSL with credentials or Confluent API keys stored in your Azure Key Vault. Nothing sensitive lives in application configuration or source.
See this connector running on your Azure tenant
Book a scoping call and we'll map your KPI families to this destination — with the security, lifecycle and depth of integration your teams require.
Streamvane by Tessovia · Azure · AWS · GCP · Your data, your keys