jetstream_bridge 4.4.1 → 4.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b0e94fdb2f61d340cd4b23ceeb108a8243f3eeece7286855290338f2b02d9ae
-  data.tar.gz: 3c89aee306f4cbf89ff7445d204e3d9357a13a59fcd5ed2c3e3061055c65a659
+  metadata.gz: 56e6cc6b519fe3d4ea947454cd57073bffe5a7929256dfafcd600eb6e5ae51ae
+  data.tar.gz: 6ffe8856a86778a6b4ae9f693745167a70b51d655fa1fac8c119ec0ce1122860
 SHA512:
-  metadata.gz: 91a2e1adcff2323ae2b4861440cb3ff28ea1615978d401ecd6fbe2d62391920ba9ff7d5108b69fd98ed8bd73331db7585ed7f7a01991c4255ce88cbae332f561
-  data.tar.gz: 8f58da0aaa623294ffbbb37e386af5cf98faf4a4c28ea498be623f74482a38e851b53b3b3817279c7121151b9dd7d259c46748e78d05f336436527a1ec087ed4
+  metadata.gz: 48af0a3efcea9a94f7093e791a6d02520b6b748c706760809a46438709d877c11662fcd92a5dd6715a0999678904af9e6a417c5cf577f755b0aecf9b9c2a3504
+  data.tar.gz: 0b151d22b8bd14d38cc2f20ec969b0892794abe74475dc1ce3b76a6773757bd64f72269e8478281e0a971ae7523e34bff808c452745fa07d1e8866d708928a64

data/CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.4.1] - 2026-01-16
+
+### Fixed
+
+- **Rails Generators** - Qualify Rails constants to avoid `JetstreamBridge::Rails::Generators` NameError during generator load
+
 ## [4.4.0] - 2025-11-24
 
 ### Changed

data/README.md

@@ -34,7 +34,7 @@ Production-ready NATS JetStream bridge for Ruby/Rails with outbox, inbox, DLQ, a
 
 ```ruby
 # Gemfile
-gem "jetstream_bridge", "~> 4.0"
+gem "jetstream_bridge", "~> 4.5"
 ```
 
 ```bash
@@ -43,22 +43,7 @@ bin/rails g jetstream_bridge:install
 bin/rails db:migrate
 ```
 
-```ruby
-# config/initializers/jetstream_bridge.rb
-JetstreamBridge.configure do |config|
-  config.nats_urls       = ENV.fetch("NATS_URLS", "nats://localhost:4222")
-  config.env             = ENV.fetch("RAILS_ENV", "development")
-  config.app_name        = "my_app"
-  config.destination_app = "worker_app"
-  config.use_outbox = true
-  config.use_inbox  = true
-  config.use_dlq    = true
-end
-
-# Note: configure only sets options; it does not connect. In Rails the Railtie
-# starts the bridge after initialization. In non-Rails apps call
-# `JetstreamBridge.startup!` (or rely on auto-connect on first publish/subscribe).
-```
+The install generator creates the initializer, migrations, and optional health check scaffold. For full configuration options and non-Rails boot flows, see [docs/GETTING_STARTED.md](docs/GETTING_STARTED.md).
 
 Publish:
 
@@ -79,6 +64,7 @@ consumer.run!
 
 - [Getting Started](docs/GETTING_STARTED.md)
 - [Production Guide](docs/PRODUCTION.md)
+- [Restricted Permissions & Provisioning](docs/RESTRICTED_PERMISSIONS.md)
 - [Testing with Mock NATS](docs/TESTING.md)
 
 ## License

data/docs/GETTING_STARTED.md

@@ -6,7 +6,7 @@ This guide covers installation, Rails setup, configuration, and basic publish/co
 
 ```ruby
 # Gemfile
-gem "jetstream_bridge", "~> 4.0"
+gem "jetstream_bridge", "~> 4.5"
 ```
 
 ```bash
@@ -39,7 +39,7 @@ Generators create:
 # config/initializers/jetstream_bridge.rb
 JetstreamBridge.configure do |config|
   config.nats_urls       = ENV.fetch("NATS_URLS", "nats://localhost:4222")
-  config.env             = ENV.fetch("RAILS_ENV", "development")
+  config.stream_name     = ENV.fetch("JETSTREAM_STREAM_NAME", "jetstream-bridge-stream")
   config.app_name        = "my_app"
   config.destination_app = ENV.fetch("DESTINATION_APP")
 

data/docs/PRODUCTION.md

@@ -32,22 +32,26 @@ production:
 ### Sizing Guidelines
 
 **Publishers (Web/API processes):**
+
 - 1-2 connections per process (uses existing AR pool)
 - Example: 4 Puma workers × 5 threads = 20 connections minimum
 
 **Consumers:**
+
 - Dedicated connections per consumer process
 - Recommended: 2-5 connections per consumer
 - Example: 3 consumer processes = 6-15 connections
 
 **Total Formula:**
-```
+
+```markdown
 Total Connections = (Web Workers × Threads) + (Consumers × 3) + 10 buffer
 ```
 
 ### Example Calculation
 
 For a typical production setup:
+
 - 4 Puma workers × 5 threads = 20 connections
 - 3 consumer processes × 3 connections = 9 connections
 - 10 connection buffer = 10 connections
@@ -74,7 +78,7 @@ JetstreamBridge.configure do |config|
   config.connect_retry_delay = 3     # Default: 2 seconds
 
   # Required configuration
-  config.env = ENV.fetch("RAILS_ENV", "production")
+  config.stream_name = ENV.fetch("JETSTREAM_STREAM_NAME", "jetstream-bridge-stream")
   config.app_name = ENV.fetch("APP_NAME", "myapp")
   config.destination_app = ENV.fetch("DESTINATION_APP")
 
@@ -135,6 +139,7 @@ end
 ### Memory Management
 
 Long-running consumers automatically:
+
 - Log health checks every 10 minutes (iterations, memory, uptime)
 - Warn when memory exceeds 1GB
 - Suggest garbage collection when heap grows large
@@ -148,7 +153,7 @@ Monitor these logs to detect memory leaks early.
 ### Key Metrics to Track
 
 | Metric | Description | Alert Threshold |
-|--------|-------------|-----------------|
+| --- | --- | --- |
 | Consumer Lag | Pending messages in stream | > 1000 messages |
 | DLQ Size | Messages in dead letter queue | > 100 messages |
 | Connection Status | Health check failures | 2 consecutive failures |
@@ -183,8 +188,8 @@ end
   },
   "stream": {
     "exists": true,
-    "name": "production-jetstream-bridge-stream",
-    "subjects": ["production.app.sync.worker"],
+    "name": "jetstream-bridge-stream",
+    "subjects": ["app.sync.worker"],
     "messages": 1523
   },
   "performance": {
@@ -192,7 +197,7 @@ end
     "health_check_duration_ms": 45.2
   },
   "config": {
-    "env": "production",
+    "stream_name": "jetstream-bridge-stream",
     "app_name": "app",
     "destination_app": "worker",
     "use_outbox": true,
@@ -236,6 +241,10 @@ jetstream_dlq = prometheus.gauge(
 
 ## Security Hardening
 
+### Permissions & Topology
+
+Keep runtime credentials least-privileged: set `config.auto_provision = false` and provision the stream/consumer during deploy (`bundle exec rake jetstream_bridge:provision` or NATS CLI). The exact durable/subject layout and minimal publish/subscribe permissions live in [RESTRICTED_PERMISSIONS.md](RESTRICTED_PERMISSIONS.md). Health checks skip stream info when `auto_provision=false`; rely on your provisioning pipeline for validation.
+
 ### Rate Limiting
 
 The health check endpoint has built-in rate limiting (1 uncached request per 5 seconds). For HTTP endpoints, add additional protection:
@@ -253,6 +262,7 @@ end
 ### Subject Validation
 
 JetStream Bridge validates subject components to prevent injection attacks. The following are automatically rejected:
+
 - NATS wildcards (`.`, `*`, `>`)
 - Spaces and control characters
 - Components exceeding 255 characters
@@ -270,6 +280,7 @@ config.nats_urls = ENV.fetch("NATS_URLS")
 ```
 
 Credentials in logs are automatically sanitized:
+
 - `nats://user:pass@host:4222` → `nats://user:***@host:4222`
 - `nats://token@host:4222` → `nats://***@host:4222`
 
@@ -345,6 +356,7 @@ spec:
 ### Health Probes
 
 **Liveness Probe:** Checks if the consumer process is running
+
 ```yaml
 livenessProbe:
   exec:
@@ -354,6 +366,7 @@ livenessProbe:
 ```
 
 **Readiness Probe:** Checks if NATS connection is healthy
+
 ```yaml
 readinessProbe:
   httpGet:
@@ -413,7 +426,7 @@ CREATE INDEX idx_inbox_stream_seq ON jetstream_inbox_events(stream, stream_seq);
 CREATE INDEX idx_inbox_status ON jetstream_inbox_events(status);
 ```
 
-2. **Partition large tables** (for high-volume applications):
+1. **Partition large tables** (for high-volume applications):
 
 ```sql
 -- Partition outbox by month
@@ -426,7 +439,7 @@ CREATE TABLE jetstream_outbox_events_2025_11
   FOR VALUES FROM ('2025-11-01') TO ('2025-12-01');
 ```
 
-3. **Archive old records** to prevent table bloat:
+1. **Archive old records** to prevent table bloat:
 
 ```ruby
 # lib/tasks/jetstream_maintenance.rake
@@ -462,24 +475,28 @@ end
 ### Common Issues
 
 **High Consumer Lag:**
+
 - Scale up consumer instances
 - Increase batch size
 - Optimize handler processing time
 - Check database connection pool
 
 **Memory Leaks:**
+
 - Monitor consumer health logs
 - Enable memory profiling
 - Check for circular references in handlers
 - Restart consumers periodically (Kubernetes handles this)
 
 **Connection Issues:**
+
 - Verify NATS server is accessible
 - Check firewall rules
 - Validate TLS certificates
 - Review connection retry settings
 
 **DLQ Growing:**
+
 - Investigate failed message patterns
 - Fix bugs in message handlers
 - Increase max_deliver for transient errors
@@ -499,5 +516,6 @@ end
 ## Support
 
 For issues or questions:
-- GitHub Issues: https://github.com/attaradev/jetstream_bridge/issues
-- Documentation: https://github.com/attaradev/jetstream_bridge
+
+- GitHub Issues: <https://github.com/attaradev/jetstream_bridge/issues>
+- Documentation: <https://github.com/attaradev/jetstream_bridge>

data/docs/RESTRICTED_PERMISSIONS.md

@@ -0,0 +1,399 @@
+# Working with Restricted NATS Permissions
+
+This guide explains how to use JetStream Bridge when your NATS user lacks JetStream API permissions (`$JS.API.*` subjects).
+
+## Problem
+
+When the NATS user has restricted permissions and cannot access JetStream API subjects, you'll see errors like:
+
+```markdown
+ERROR -- : [JetstreamBridge::ConnectionManager] NATS error: 'Permissions Violation for Publish to "$JS.API.CONSUMER.INFO.{stream}.{consumer}"'
+NATS::IO::Timeout: nats: timeout
+```
+
+This happens because:
+
+1. JetStream Bridge tries to verify consumer configuration using `$JS.API.CONSUMER.INFO.*`
+2. The NATS user doesn't have permission to publish to these API subjects
+3. The connection is terminated, causing timeout errors
+
+## Solution Overview
+
+When you cannot modify NATS server permissions, you need to:
+
+0. **Turn off runtime provisioning** so the app never calls `$JS.API.*`:
+   - Set `config.auto_provision = false`
+   - Provision stream + consumer once with admin credentials (CLI below or `bundle exec rake jetstream_bridge:provision`)
+1. **Pre-create the consumer** using a privileged NATS account
+2. **Ensure the consumer configuration matches** what your app expects
+
+> Tip: When `auto_provision=false`, the app still connects/publishes/consumes but skips JetStream management APIs (account_info, stream_info, consumer_info). Health checks will report basic connectivity only.
+
+---
+
+## Runtime requirements (least privilege)
+
+- Config: `config.auto_provision = false`, `config.stream_name` set explicitly.
+- Topology: stream + durable consumer must be pre-provisioned (via `bundle exec rake jetstream_bridge:provision` or NATS CLI).
+- NATS permissions for runtime creds:
+  - publish allow: `">"` (or narrowed to your business subjects) and `$JS.API.CONSUMER.MSG.NEXT.{stream_name}.{app_name}-workers`
+  - subscribe allow: `">"` (or narrowed) and `_INBOX.>` (responses for pull consumers)
+- Health check will only report connectivity (stream info skipped).
+
+### Topology required
+
+- Stream: `config.stream_name` (retention: workqueue, storage: file).
+- Subjects:
+  - Publish: `{app_name}.sync.{destination_app}`
+  - Consume: `{destination_app}.sync.{app_name}`
+  - DLQ (if enabled): `{app_name}.sync.dlq`
+- Durable consumer: `{app_name}-workers` filtering on `{destination_app}.sync.{app_name}`.
+
+---
+
+## Option A: Provision with the built-in task (creates stream + consumer)
+
+Run this from CI/deploy with admin NATS credentials:
+
+```bash
+# Uses your configured stream/app/destination to create the stream + durable consumer
+NATS_URLS="nats://admin:pass@10.199.12.34:4222" \
+bundle exec rake jetstream_bridge:provision
+```
+
+This is the easiest way to keep `auto_provision=false` in runtime while still reusing the bridge’s topology logic (subjects, DLQ, overlap guard).
+
+## Option B: Pre-create the Consumer using NATS CLI
+
+### Install NATS CLI
+
+```bash
+# Download from https://github.com/nats-io/natscli/releases
+curl -sf https://binaries.nats.dev/nats-io/natscli/nats@latest | sh
+
+# Or using Homebrew (macOS)
+brew install nats-io/nats-tools/nats
+```
+
+### Create the Consumer
+
+You need to create a durable pull consumer with the exact configuration your app expects.
+
+**Required values from your JetStream Bridge config:**
+
+- **Stream name**: `JETSTREAM_STREAM_NAME` (e.g., `jetstream-bridge-stream`)
+- **Consumer name**: `{app_name}-workers` (e.g., `pwas-workers`)
+- **Filter subject**: `{app_name}.sync.{destination_app}` (e.g., `pwas-workers.sync.heavyworth`)
+
+**Create consumer command:**
+
+```bash
+# Connect using a privileged NATS account
+nats context save admin \
+  --server=nats://admin-user:admin-pass@10.199.12.34:4222 \
+  --description="Admin account for consumer creation"
+
+# Select the context
+nats context select admin
+
+# Create the consumer
+nats consumer add production-jetstream-bridge-stream production-pwas-workers \
+  --filter "production.pwas-workers.sync.heavyworth" \
+  --ack explicit \
+  --pull \
+  --deliver all \
+  --max-deliver 5 \
+  --ack-wait 30s \
+  --replay instant \
+  --max-pending 25000
+```
+
+**With backoff (recommended for production):**
+
+```bash
+nats consumer add production-jetstream-bridge-stream production-pwas-workers \
+  --filter "production.pwas-workers.sync.heavyworth" \
+  --ack explicit \
+  --pull \
+  --deliver all \
+  --max-deliver 5 \
+  --ack-wait 30s \
+  --backoff 1s,5s,15s,30s,60s \
+  --replay instant \
+  --max-pending 25000
+```
+
+### Verify Consumer Creation
+
+```bash
+nats consumer info production-jetstream-bridge-stream production-pwas-workers
+```
+
+Expected output:
+
+```bash
+Information for Consumer production-jetstream-bridge-stream > production-pwas-workers
+
+Configuration:
+
+        Durable Name: production-pwas-workers
+      Filter Subject: production.pwas-workers.sync.heavyworth
+          Ack Policy: explicit
+            Ack Wait: 30s
+       Replay Policy: instant
+  Maximum Deliveries: 5
+             Backoff: [1s 5s 15s 30s 60s]
+
+State:
+
+  Last Delivered Message: Consumer sequence: 0 Stream sequence: 0
+    Acknowledgment Floor: Consumer sequence: 0 Stream sequence: 0
+        Pending Messages: 0
+    Redelivered Messages: 0
+```
+
+---
+
+## Step 2: Configure JetStream Bridge
+
+Configure JetStream Bridge to avoid JetStream management APIs at runtime (pre-provisioning handles them instead):
+
+```ruby
+# config/initializers/jetstream_bridge.rb
+JetstreamBridge.configure do |config|
+  config.nats_urls = ENV.fetch("NATS_URLS")
+  config.stream_name = "jetstream-bridge-stream"
+  config.app_name = "pwas-workers"
+  config.destination_app = "heavyworth"
+  config.auto_provision = false
+
+  config.use_outbox = true
+  config.use_inbox = true
+  config.use_dlq = true
+
+  # These settings MUST match the pre-created consumer
+  config.max_deliver = 5
+  config.ack_wait = "30s"
+  config.backoff = %w[1s 5s 15s 30s 60s]
+end
+```
+
+**Critical:** The `max_deliver`, `ack_wait`, and `backoff` values in your config **must exactly match** the pre-created consumer configuration. If they don't match, messages may be redelivered incorrectly.
+
+---
+
+## Step 3: Deploy and Verify
+
+### Deploy the Updated Gem
+
+If you're working on the jetstream_bridge gem itself:
+
+```bash
+# Build the gem
+gem build jetstream_bridge.gemspec
+
+# Install locally for testing
+gem install ./jetstream_bridge-4.5.0.gem
+
+# Or update in your application's Gemfile.lock
+bundle update jetstream_bridge
+```
+
+If this is a local modification, you can point your Gemfile to the local path:
+
+```ruby
+# Gemfile (temporary for testing)
+gem 'jetstream_bridge', path: '/path/to/local/jetstream_bridge'
+```
+
+### Restart the Service
+
+```bash
+sudo systemctl restart pwas_production_sync
+```
+
+### Monitor the Logs
+
+```bash
+sudo journalctl -u pwas_production_sync -f
+```
+
+**Expected success output:**
+
+```bash
+INFO -- : [JetstreamBridge::ConnectionManager] Connected to NATS (1 server): nats://pwas:***@10.199.12.34:4222
+INFO -- : [DataSync] Consumer starting (durable=production-pwas-workers, batch=25, dest="heavyworth")
+INFO -- : [DataSync] run! started successfully
+```
+
+Health checks will report connectivity only when `auto_provision=false` (stream info is skipped to avoid `$JS.API.STREAM.INFO`).
+
+**If you still see errors:**
+
+1. **Timeout during subscribe** - The pre-created consumer name/filter might not match. Verify:
+
+   ```bash
+   nats consumer ls production-jetstream-bridge-stream
+   ```
+
+2. **Permission violations on fetch** - The NATS user also needs permission to fetch messages. Minimum required:
+
+   ```conf
+   subscribe: {
+     allow: ["production.>", "_INBOX.>"]
+   }
+   ```
+
+## Maintenance
+
+### Updating Consumer Configuration
+
+If you need to change consumer settings (e.g., increase `max_deliver`):
+
+1. **Stop your application** to prevent message processing
+
+   ```bash
+   sudo systemctl stop pwas_production_sync
+   ```
+
+2. **Delete the old consumer** (using privileged account)
+
+   ```bash
+   nats consumer rm production-jetstream-bridge-stream production-pwas-workers -f
+   ```
+
+3. **Create the new consumer** with updated settings
+
+   ```bash
+   nats consumer add production-jetstream-bridge-stream production-pwas-workers \
+     --filter "production.pwas-workers.sync.heavyworth" \
+     --ack explicit \
+     --pull \
+     --deliver all \
+     --max-deliver 10 \
+     --ack-wait 60s \
+     --backoff 2s,10s,30s,60s,120s \
+     --replay instant \
+     --max-pending 25000
+   ```
+
+4. **Update your application config** to match
+
+   ```ruby
+   config.max_deliver = 10
+   config.ack_wait = "60s"
+   config.backoff = %w[2s 10s 30s 60s 120s]
+   ```
+
+5. **Restart your application**
+
+   ```bash
+   sudo systemctl start pwas_production_sync
+   ```
+
+### Monitoring
+
+Add monitoring to detect configuration drift:
+
+```ruby
+# Check consumer exists and is healthy
+health = JetstreamBridge.health_check
+unless health[:healthy]
+  alert("JetStream consumer unhealthy: #{health}")
+end
+```
+
+---
+
+## Troubleshooting
+
+### Consumer doesn't receive messages
+
+**Check stream has messages:**
+
+```bash
+nats stream info production-jetstream-bridge-stream
+```
+
+**Verify filter subject matches your topology:**
+
+```bash
+# App publishes to:   {app_name}.sync.{destination_app}
+# Consumer filters on: {destination_app}.sync.{app_name}
+```
+
+### Service keeps restarting
+
+Check if the issue is:
+
+1. **Consumer doesn't exist** - Pre-create it with NATS CLI
+2. **Filter subject mismatch** - Verify with `nats consumer info`
+3. **Permissions still insufficient** - User needs subscribe permissions on the filtered subject
+4. **Wrong stream name** - Ensure stream name matches your configured `config.stream_name`
+
+---
+
+## Security Considerations
+
+1. **Consumer pre-creation requires privileged access** - Keep admin credentials secure
+2. **Configuration drift risk** - If app config doesn't match consumer config, message delivery may fail silently
+3. **No automatic recovery** - If consumer is deleted, it won't be recreated automatically
+4. **Consider automation** - Use infrastructure-as-code (Terraform, Ansible) to manage consumer creation
+
+---
+
+## Example: Production Setup for pwas-api
+
+Based on your logs, here's the exact setup:
+
+```bash
+# 1. Pre-create the consumer (as admin)
+nats consumer add pwas-heavyworth-sync production-pwas-workers \
+  --filter "production.pwas-workers.sync.heavyworth" \
+  --ack explicit \
+  --pull \
+  --deliver all \
+  --max-deliver 5 \
+  --ack-wait 30s \
+  --backoff 1s,5s,15s,30s,60s \
+  --replay instant
+```
+
+```ruby
+# 2. Update config/initializers/jetstream_bridge.rb
+JetstreamBridge.configure do |config|
+  config.nats_urls = "nats://pwas:***@10.199.12.34:4222"
+  config.stream_name = "jetstream-bridge-stream"
+  config.app_name = "pwas-workers"
+  config.destination_app = "heavyworth"
+  config.max_deliver = 5
+  config.ack_wait = "30s"
+  config.backoff = %w[1s 5s 15s 30s 60s]
+end
+```
+
+**Note:** Verify your exact stream name and consumer durable (`app_name-workers`) match what was provisioned.
+
+---
+
+## Alternative: Request Minimal Permissions
+
+If you have any influence over NATS permissions, request only these minimal subjects:
+
+```conf
+# Minimal permissions needed for JetStream Bridge consumer
+publish: {
+  allow: [
+    ">",                                   # Your app subjects (narrow if desired)
+    "$JS.API.CONSUMER.MSG.NEXT.{stream_name}.{app_name}-workers",  # Fetch messages (required)
+  ]
+}
+subscribe: {
+  allow: [
+    ">",                                   # Your app subjects (narrow if desired)
+    "_INBOX.>",                            # Request-reply responses (required)
+  ]
+}
+```
+
+These are read-only operations and don't allow creating/modifying streams or consumers.

data/docs/TESTING.md

@@ -36,7 +36,7 @@ RSpec.describe MyService do
     JetstreamBridge::TestHelpers.enable_test_mode!
 
     JetstreamBridge.configure do |config|
-      config.env = 'test'
+      config.stream_name = 'jetstream-bridge-stream'
       config.app_name = 'my_app'
       config.destination_app = 'worker'
     end
@@ -283,7 +283,7 @@ before do
   allow(JetstreamBridge::Topology).to receive(:ensure!)
 
   JetstreamBridge.configure do |config|
-    config.env = 'test'
+    config.stream_name = 'jetstream-bridge-stream'
     config.app_name = 'api'
     config.destination_app = 'worker'
   end
@@ -298,7 +298,7 @@ it 'publishes through JetstreamBridge' do
 
   expect(result).to be_publish_success
   expect(result.event_id).to be_present
-  expect(result.subject).to eq('test.api.sync.worker')
+   expect(result.subject).to eq('api.sync.worker')
 
   # Verify in storage
   storage = JetstreamBridge::TestHelpers.mock_storage
@@ -315,7 +315,7 @@ it 'consumes through JetstreamBridge' do
 
   # Publish message to destination subject
   mock_jts.publish(
-    'test.worker.sync.api',
+    'worker.sync.api',
     Oj.dump({
       'event_id' => 'event-1',
       'schema_version' => 1,
@@ -338,7 +338,7 @@ it 'consumes through JetstreamBridge' do
 
   # Mock subscription
   subscription = mock_jts.pull_subscribe(
-    'test.worker.sync.api',
+    'worker.sync.api',
     'test-consumer',
     stream: 'test-jetstream-bridge-stream'
   )