omnibase_infra 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

omnibase_infra/event_bus/event_bus_kafka.py

@@ -29,10 +29,6 @@ Environment Variables:
             Default: "local"
             Example: "dev", "staging", "prod"
 
-        KAFKA_GROUP: Consumer group identifier
-            Default: "default"
-            Example: "my-service-group"
-
     Timeout and Retry Settings:
         KAFKA_TIMEOUT_SECONDS: Timeout for Kafka operations (integer seconds)
             Default: 30
@@ -134,6 +130,7 @@ Usage:
     ```python
     from omnibase_infra.event_bus.event_bus_kafka import EventBusKafka
     from omnibase_infra.event_bus.models.config import ModelKafkaEventBusConfig
+    from omnibase_infra.models import ModelNodeIdentity
 
     # Option 1: Use defaults with environment variable overrides
     bus = EventBusKafka.default()
@@ -147,10 +144,17 @@ Usage:
     bus = EventBusKafka(config=config)
     await bus.start()
 
-    # Subscribe to a topic
+    # Subscribe to a topic with node identity
+    identity = ModelNodeIdentity(
+        env="dev",
+        service="my-service",
+        node_name="event-processor",
+        version="v1",
+    )
+
     async def handler(msg):
         print(f"Received: {msg.value}")
-    unsubscribe = await bus.subscribe("events", "group1", handler)
+    unsubscribe = await bus.subscribe("events", identity, handler)
 
     # Publish a message
     await bus.publish("events", b"key", b"value")
@@ -163,6 +167,10 @@ Usage:
 Protocol Compatibility:
     This class implements ProtocolEventBus from omnibase_core using duck typing
     (no explicit inheritance required per ONEX patterns).
+
+    TODO: Consider formalizing the EventBusKafka interface as a Protocol
+    (ProtocolEventBusKafka) in the future to enable better static type checking
+    and IDE support for consumers that depend on Kafka-specific features.
 """
 
 from __future__ import annotations
@@ -180,7 +188,7 @@ from uuid import UUID, uuid4
 from aiokafka import AIOKafkaConsumer, AIOKafkaProducer
 from aiokafka.errors import KafkaError
 
-from omnibase_infra.enums import EnumInfraTransportType
+from omnibase_infra.enums import EnumConsumerGroupPurpose, EnumInfraTransportType
 from omnibase_infra.errors import (
     InfraConnectionError,
     InfraTimeoutError,
@@ -197,6 +205,8 @@ from omnibase_infra.event_bus.models import (
 )
 from omnibase_infra.event_bus.models.config import ModelKafkaEventBusConfig
 from omnibase_infra.mixins import MixinAsyncCircuitBreaker
+from omnibase_infra.models import ModelNodeIdentity
+from omnibase_infra.utils import compute_consumer_group_id
 
 logger = logging.getLogger(__name__)
 
@@ -215,29 +225,30 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         - Circuit breaker for connection failure protection
         - Retry with exponential backoff on publish failures
         - Dead letter queue (DLQ) for failed message processing
-        - Environment and group-based message routing
+        - Environment-based message routing
         - Proper async producer/consumer lifecycle management
 
     Attributes:
         environment: Environment identifier (e.g., "local", "dev", "prod")
-        group: Consumer group identifier
         adapter: Returns self (for protocol compatibility)
 
     Architecture:
         This class uses mixin composition to organize functionality:
-        - MixinKafkaBroadcast: Environment/group broadcast messaging, envelope publishing
+        - MixinKafkaBroadcast: Environment broadcast messaging, envelope publishing
         - MixinKafkaDlq: Dead letter queue handling and metrics
         - MixinAsyncCircuitBreaker: Circuit breaker resilience pattern
 
         The core class provides:
         - Factory methods (3): from_config, from_yaml, default
-        - Properties (4): config, adapter, environment, group
+        - Properties (3): config, adapter, environment
         - Lifecycle methods (4): start, initialize, shutdown, close
         - Pub/Sub methods (3): publish, subscribe, start_consuming
         - Health check (1): health_check
 
     Example:
         ```python
+        from omnibase_infra.models import ModelNodeIdentity
+
         config = ModelKafkaEventBusConfig(
             bootstrap_servers="kafka:9092",
             environment="dev",
@@ -245,10 +256,17 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         bus = EventBusKafka(config=config)
         await bus.start()
 
-        # Subscribe
+        # Subscribe with node identity
+        identity = ModelNodeIdentity(
+            env="dev",
+            service="my-service",
+            node_name="event-processor",
+            version="v1",
+        )
+
         async def handler(msg):
             print(f"Received: {msg.value}")
-        unsubscribe = await bus.subscribe("events", "group1", handler)
+        unsubscribe = await bus.subscribe("events", identity, handler)
 
         # Publish
         await bus.publish("events", b"key", b"value")
@@ -296,7 +314,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         # Apply config values
         self._bootstrap_servers = config.bootstrap_servers
         self._environment = config.environment
-        self._group = config.group
         self._timeout_seconds = config.timeout_seconds
         self._max_retry_attempts = config.max_retry_attempts
         self._retry_backoff_base = config.retry_backoff_base
@@ -450,15 +467,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         """
         return self._environment
 
-    @property
-    def group(self) -> str:
-        """Get the consumer group identifier.
-
-        Returns:
-            Consumer group string
-        """
-        return self._group
-
     async def start(self) -> None:
         """Start the event bus and connect to Kafka.
 
@@ -511,7 +519,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
                     "EventBusKafka started",
                     extra={
                         "environment": self._environment,
-                        "group": self._group,
                         "bootstrap_servers": self._sanitize_bootstrap_servers(
                             self._bootstrap_servers
                         ),
@@ -612,7 +619,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         Args:
             config: Configuration dictionary with optional keys:
                 - environment: Override environment setting
-                - group: Override group setting
                 - bootstrap_servers: Override bootstrap servers
                 - timeout_seconds: Override timeout setting
         """
@@ -620,8 +626,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         async with self._lock:
             if "environment" in config:
                 self._environment = str(config["environment"])
-            if "group" in config:
-                self._group = str(config["group"])
             if "bootstrap_servers" in config:
                 self._bootstrap_servers = str(config["bootstrap_servers"])
             if "timeout_seconds" in config:
@@ -696,7 +700,7 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
 
         logger.info(
             "EventBusKafka closed",
-            extra={"environment": self._environment, "group": self._group},
+            extra={"environment": self._environment},
         )
 
     async def publish(
@@ -739,7 +743,7 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         # Create headers if not provided
         if headers is None:
             headers = ModelEventHeaders(
-                source=f"{self._environment}.{self._group}",
+                source=self._environment,
                 event_type=topic,
                 timestamp=datetime.now(UTC),
             )
@@ -915,32 +919,58 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
     async def subscribe(
         self,
         topic: str,
-        group_id: str,
+        node_identity: ModelNodeIdentity,
         on_message: Callable[[ModelEventMessage], Awaitable[None]],
+        *,
+        purpose: EnumConsumerGroupPurpose = EnumConsumerGroupPurpose.CONSUME,
     ) -> Callable[[], Awaitable[None]]:
         """Subscribe to topic with callback handler.
 
         Registers a callback to be invoked for each message received on the topic.
         Returns an unsubscribe function to remove the subscription.
 
+        The consumer group ID is derived from the node identity using the canonical
+        format: ``{env}.{service}.{node_name}.{purpose}.{version}``.
+
         Note: Unlike typical Kafka consumer groups, this implementation maintains
         a subscriber registry and fans out messages to all registered callbacks,
         matching the EventBusInmemory interface.
 
         Args:
             topic: Topic to subscribe to
-            group_id: Consumer group identifier for this subscription
+            node_identity: Node identity used to derive the consumer group ID.
+                Contains env, service, node_name, and version components.
             on_message: Async callback invoked for each message
+            purpose: Consumer group purpose classification. Defaults to CONSUME.
+                Used in the consumer group ID derivation for disambiguation.
 
         Returns:
             Async unsubscribe function to remove this subscription
 
         Example:
             ```python
+            from omnibase_infra.models import ModelNodeIdentity
+            from omnibase_infra.enums import EnumConsumerGroupPurpose
+
+            identity = ModelNodeIdentity(
+                env="dev",
+                service="my-service",
+                node_name="event-processor",
+                version="v1",
+            )
+
             async def handler(msg):
                 print(f"Received: {msg.value}")
 
-            unsubscribe = await bus.subscribe("events", "group1", handler)
+            # Standard subscription (group_id: dev.my-service.event-processor.consume.v1)
+            unsubscribe = await bus.subscribe("events", identity, handler)
+
+            # With explicit purpose
+            unsubscribe = await bus.subscribe(
+                "events", identity, handler,
+                purpose=EnumConsumerGroupPurpose.INTROSPECTION,
+            )
+
             # ... later ...
             await unsubscribe()
             ```
@@ -948,22 +978,27 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         subscription_id = str(uuid4())
         correlation_id = uuid4()
 
+        # Derive consumer group ID from node identity (no overrides allowed)
+        effective_group_id = compute_consumer_group_id(node_identity, purpose)
+
         # Validate topic name
         self._validate_topic_name(topic, correlation_id)
 
         async with self._lock:
             # Add to subscriber registry
-            self._subscribers[topic].append((group_id, subscription_id, on_message))
+            self._subscribers[topic].append(
+                (effective_group_id, subscription_id, on_message)
+            )
 
             # Start consumer for this topic if not already running
             if topic not in self._consumers and self._started:
-                await self._start_consumer_for_topic(topic, group_id)
+                await self._start_consumer_for_topic(topic, effective_group_id)
 
             logger.debug(
                 "Subscriber added",
                 extra={
                     "topic": topic,
-                    "group_id": group_id,
+                    "group_id": effective_group_id,
                     "subscription_id": subscription_id,
                 },
             )
@@ -983,7 +1018,7 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
                         "Subscriber removed",
                         extra={
                             "topic": topic,
-                            "group_id": group_id,
+                            "group_id": effective_group_id,
                             "subscription_id": subscription_id,
                         },
                     )
@@ -1006,9 +1041,13 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
 
         Args:
             topic: Topic to consume from
-            group_id: Consumer group ID
+            group_id: Fully qualified consumer group ID. This should be derived
+                from ``compute_consumer_group_id()`` or an explicit override.
+                The ID is used directly without any prefix modification.
 
         Raises:
+            ProtocolConfigurationError: If group_id is empty (must be derived from
+                compute_consumer_group_id or provided as explicit override)
             InfraTimeoutError: If consumer startup times out after timeout_seconds
             InfraConnectionError: If consumer fails to connect to Kafka brokers
         """
@@ -1018,15 +1057,29 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
         correlation_id = uuid4()
         sanitized_servers = self._sanitize_bootstrap_servers(self._bootstrap_servers)
 
-        # Normalize empty string to default group (treats "" same as None)
-        # This ensures consistent behavior when group_id is unset or empty
-        effective_group_id = group_id.strip() if group_id else self._group
+        # Use group_id directly - it's already fully qualified from compute_consumer_group_id()
+        # or an explicit override. Empty group_id indicates a bug in the caller.
+        effective_group_id = group_id.strip()
+        if not effective_group_id:
+            context = ModelInfraErrorContext.with_correlation(
+                correlation_id=correlation_id,
+                transport_type=EnumInfraTransportType.KAFKA,
+                operation="start_consumer",
+                target_name=f"kafka.{topic}",
+            )
+            raise ProtocolConfigurationError(
+                f"Consumer group ID is required for topic '{topic}'. "
+                "Internal error: compute_consumer_group_id() should have been called.",
+                context=context,
+                parameter="group_id",
+                value=group_id,
+            )
 
         # Apply consumer configuration from config model
         consumer = AIOKafkaConsumer(
             topic,
             bootstrap_servers=self._bootstrap_servers,
-            group_id=f"{self._environment}.{effective_group_id}",
+            group_id=effective_group_id,
             auto_offset_reset=self._config.auto_offset_reset,
             enable_auto_commit=self._config.enable_auto_commit,
         )
@@ -1194,6 +1247,15 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
                     )
                     break
 
+                # Get subscribers snapshot early - needed for consumer group in DLQ
+                async with self._lock:
+                    subscribers = list(self._subscribers.get(topic, []))
+
+                # Extract consumer group for DLQ traceability (all subscribers share the same consumer)
+                effective_consumer_group = (
+                    subscribers[0][0] if subscribers else "unknown"
+                )
+
                 # Convert Kafka message to ModelEventMessage - handle conversion errors
                 try:
                     event_message = self._kafka_msg_to_model(msg, topic)
@@ -1215,13 +1277,10 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
                         error=e,
                         correlation_id=correlation_id,
                         failure_type="deserialization_error",
+                        consumer_group=effective_consumer_group,
                     )
                     continue  # Skip this message but continue consuming
 
-                # Get subscribers snapshot
-                async with self._lock:
-                    subscribers = list(self._subscribers.get(topic, []))
-
                 # Dispatch to all subscribers
                 for group_id, subscription_id, callback in subscribers:
                     try:
@@ -1255,6 +1314,7 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
                                 failed_message=event_message,
                                 error=e,
                                 correlation_id=correlation_id,
+                                consumer_group=group_id,
                             )
                         else:
                             # Message still has retries available - log for potential republish
@@ -1340,7 +1400,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
                 - healthy: Whether the bus is operational
                 - started: Whether start() has been called
                 - environment: Current environment
-                - group: Current consumer group
                 - bootstrap_servers: Kafka bootstrap servers
                 - circuit_state: Current circuit breaker state
                 - subscriber_count: Total number of active subscriptions
@@ -1371,7 +1430,6 @@ class EventBusKafka(MixinKafkaBroadcast, MixinKafkaDlq, MixinAsyncCircuitBreaker
             "healthy": started and producer_healthy,
             "started": started,
             "environment": self._environment,
-            "group": self._group,
             "bootstrap_servers": self._sanitize_bootstrap_servers(
                 self._bootstrap_servers
             ),

omnibase_infra/event_bus/mixin_kafka_broadcast.py

@@ -26,7 +26,6 @@ Usage:
 Design Note:
     This mixin assumes the parent class has:
     - self._environment: str for environment context
-    - self._group: str for consumer group context
     - self.publish(): Async method to publish messages
 """
 
@@ -51,7 +50,6 @@ class ProtocolKafkaBroadcastHost(Protocol):
     """
 
     _environment: str
-    _group: str
 
     async def publish(
         self,
@@ -77,7 +75,6 @@ class MixinKafkaBroadcast:
 
     Required attributes from parent class:
         _environment: str for environment context
-        _group: str for consumer group context
 
     Required methods from parent class:
         publish: Async method to publish messages to a topic
@@ -85,7 +82,6 @@ class MixinKafkaBroadcast:
 
     # Type hints for attributes expected from parent class
     _environment: str
-    _group: str
 
     async def broadcast_to_environment(
         self: ProtocolKafkaBroadcastHost,
@@ -108,7 +104,7 @@ class MixinKafkaBroadcast:
         value = json.dumps(value_dict).encode("utf-8")
 
         headers = ModelEventHeaders(
-            source=f"{self._environment}.{self._group}",
+            source=self._environment,
             event_type="broadcast",
             content_type="application/json",
             timestamp=datetime.now(UTC),
@@ -136,7 +132,7 @@ class MixinKafkaBroadcast:
         value = json.dumps(value_dict).encode("utf-8")
 
         headers = ModelEventHeaders(
-            source=f"{self._environment}.{self._group}",
+            source=self._environment,
             event_type="group_command",
             content_type="application/json",
             timestamp=datetime.now(UTC),
@@ -172,7 +168,7 @@ class MixinKafkaBroadcast:
         value = json.dumps(envelope_dict).encode("utf-8")
 
         headers = ModelEventHeaders(
-            source=f"{self._environment}.{self._group}",
+            source=self._environment,
             event_type=topic,
             content_type="application/json",
             timestamp=datetime.now(UTC),

omnibase_infra/event_bus/mixin_kafka_dlq.py

@@ -32,7 +32,6 @@ Design Note:
     This mixin assumes the parent class has:
     - self._config: ModelKafkaEventBusConfig with dead_letter_topic
     - self._environment: str for environment context
-    - self._group: str for consumer group context
     - self._producer: AIOKafkaProducer | None
     - self._producer_lock: asyncio.Lock for producer access
     - self._timeout_seconds: int for publish timeout
@@ -75,7 +74,6 @@ class ProtocolKafkaDlqHost(Protocol):
     # Attributes from parent class (EventBusKafka)
     _config: ModelKafkaEventBusConfig
     _environment: str
-    _group: str
     _producer: AIOKafkaProducer | None
     _producer_lock: asyncio.Lock
     _timeout_seconds: int
@@ -212,6 +210,8 @@ class MixinKafkaDlq:
         failed_message: ModelEventMessage,
         error: Exception,
         correlation_id: UUID,
+        *,
+        consumer_group: str,
     ) -> None:
         """Publish failed message to dead letter queue with metrics and alerting.
 
@@ -232,6 +232,8 @@ class MixinKafkaDlq:
             failed_message: The message that failed processing
             error: The exception that caused the failure
             correlation_id: Correlation ID for tracking
+            consumer_group: Consumer group ID that processed the message.
+                Required for DLQ traceability.
 
         Note:
             This method logs errors if DLQ publishing fails but does not raise
@@ -298,7 +300,7 @@ class MixinKafkaDlq:
 
         # Create DLQ headers with failure metadata
         dlq_headers = ModelEventHeaders(
-            source=f"{self._environment}.{self._group}",
+            source=self._environment,
             event_type="dlq_message",
             content_type="application/json",
             correlation_id=correlation_id,
@@ -451,7 +453,7 @@ class MixinKafkaDlq:
             dlq_error_message=dlq_error_message,
             timestamp=end_time,
             environment=self._environment,
-            consumer_group=self._group,
+            consumer_group=consumer_group,
         )
 
         # Update DLQ metrics (copy-on-write pattern)
@@ -504,6 +506,8 @@ class MixinKafkaDlq:
         error: Exception,
         correlation_id: UUID,
         failure_type: str,
+        *,
+        consumer_group: str,
     ) -> None:
         """Publish raw Kafka message to DLQ when deserialization fails.
 
@@ -518,6 +522,8 @@ class MixinKafkaDlq:
             error: The exception that caused the failure
             correlation_id: Correlation ID for tracking
             failure_type: Type of failure (e.g., "deserialization_error")
+            consumer_group: Consumer group ID that processed the message.
+                Required for DLQ traceability.
 
         Note:
             This method logs errors if DLQ publishing fails but does not raise
@@ -593,7 +599,7 @@ class MixinKafkaDlq:
 
         # Create DLQ headers
         dlq_headers = ModelEventHeaders(
-            source=f"{self._environment}.{self._group}",
+            source=self._environment,
             event_type="dlq_raw_message",
             content_type="application/json",
             correlation_id=correlation_id,
@@ -746,7 +752,7 @@ class MixinKafkaDlq:
             dlq_error_message=dlq_error_message,
             timestamp=end_time,
             environment=self._environment,
-            consumer_group=self._group,
+            consumer_group=consumer_group,
         )
 
         # Update DLQ metrics

omnibase_infra/event_bus/models/config/model_kafka_event_bus_config.py

@@ -27,10 +27,6 @@ Environment Variables:
             Default: "local"
             Example: "dev", "staging", "prod"
 
-        KAFKA_GROUP: Consumer group identifier
-            Default: "default"
-            Example: "my-service-group"
-
     Timeout and Retry Settings (with validation):
         KAFKA_TIMEOUT_SECONDS: Timeout for operations (integer, 1-300)
             Default: 30
@@ -124,7 +120,6 @@ class ModelKafkaEventBusConfig(BaseModel):
     Attributes:
         bootstrap_servers: Kafka bootstrap servers (host:port format)
         environment: Environment identifier for message routing
-        group: Consumer group identifier for message routing
         timeout_seconds: Timeout for Kafka operations in seconds
         max_retry_attempts: Maximum retry attempts for publish operations
         retry_backoff_base: Base delay in seconds for exponential backoff
@@ -167,11 +162,6 @@ class ModelKafkaEventBusConfig(BaseModel):
         description="Environment identifier for message routing (e.g., 'local', 'dev', 'prod')",
         min_length=1,
     )
-    group: str = Field(
-        default="default",
-        description="Consumer group identifier for message routing",
-        min_length=1,
-    )
     timeout_seconds: int = Field(
         default=30,
         description="Timeout for Kafka operations in seconds",
@@ -408,73 +398,6 @@ class ModelKafkaEventBusConfig(BaseModel):
             )
         return v.strip()
 
-    @field_validator("group", mode="before")
-    @classmethod
-    def validate_group(cls, v: object) -> str:
-        """Validate consumer group identifier.
-
-        Args:
-            v: Group value (any type before Pydantic conversion)
-
-        Returns:
-            Validated group string
-
-        Raises:
-            ProtocolConfigurationError: If group is empty, invalid type, or contains invalid characters
-        """
-        context = ModelInfraErrorContext(
-            transport_type=EnumInfraTransportType.KAFKA,
-            operation="validate_config",
-            target_name="kafka_config",
-            correlation_id=uuid4(),
-        )
-
-        if v is None:
-            raise ProtocolConfigurationError(
-                "group cannot be None",
-                context=context,
-                parameter="group",
-                value=None,
-            )
-        if not isinstance(v, str):
-            raise ProtocolConfigurationError(
-                f"group must be a string, got {type(v).__name__}",
-                context=context,
-                parameter="group",
-                value=type(v).__name__,
-            )
-
-        group_name = v.strip()
-        if not group_name:
-            raise ProtocolConfigurationError(
-                "group cannot be empty",
-                context=context,
-                parameter="group",
-                value=v,
-            )
-
-        # Kafka group names have similar restrictions to topic names
-        # but are generally more permissive
-        if len(group_name) > 255:
-            raise ProtocolConfigurationError(
-                f"group name '{group_name}' exceeds maximum length of 255 characters",
-                context=context,
-                parameter="group",
-                value=group_name,
-            )
-
-        # Check for invalid characters (control characters, null bytes)
-        for char in group_name:
-            if ord(char) < 32 or char == "\x7f":
-                raise ProtocolConfigurationError(
-                    f"group name '{group_name}' contains invalid control character",
-                    context=context,
-                    parameter="group",
-                    value=group_name,
-                )
-
-        return group_name
-
     def apply_environment_overrides(self) -> ModelKafkaEventBusConfig:
         """Apply environment variable overrides to configuration.
 
@@ -482,7 +405,6 @@ class ModelKafkaEventBusConfig(BaseModel):
             - KAFKA_BOOTSTRAP_SERVERS -> bootstrap_servers
             - KAFKA_TIMEOUT_SECONDS -> timeout_seconds
             - KAFKA_ENVIRONMENT -> environment
-            - KAFKA_GROUP -> group
             - KAFKA_MAX_RETRY_ATTEMPTS -> max_retry_attempts
             - KAFKA_CIRCUIT_BREAKER_THRESHOLD -> circuit_breaker_threshold
 
@@ -495,7 +417,6 @@ class ModelKafkaEventBusConfig(BaseModel):
             "KAFKA_BOOTSTRAP_SERVERS": "bootstrap_servers",
             "KAFKA_TIMEOUT_SECONDS": "timeout_seconds",
             "KAFKA_ENVIRONMENT": "environment",
-            "KAFKA_GROUP": "group",
             "KAFKA_MAX_RETRY_ATTEMPTS": "max_retry_attempts",
             "KAFKA_CIRCUIT_BREAKER_THRESHOLD": "circuit_breaker_threshold",
             "KAFKA_CIRCUIT_BREAKER_RESET_TIMEOUT": "circuit_breaker_reset_timeout",
@@ -625,7 +546,6 @@ class ModelKafkaEventBusConfig(BaseModel):
         base_config = cls(
             bootstrap_servers="localhost:9092",
             environment="local",
-            group="default",
             timeout_seconds=30,
             max_retry_attempts=3,
             retry_backoff_base=1.0,
@@ -662,7 +582,6 @@ class ModelKafkaEventBusConfig(BaseModel):
             ```yaml
             bootstrap_servers: "kafka:9092"
             environment: "prod"
-            group: "my-service"
             timeout_seconds: 60
             max_retry_attempts: 5
             circuit_breaker_threshold: 10