omnibase_infra 0.2.6__py3-none-any.whl

omnibase_infra/utils/correlation.py

@@ -0,0 +1,208 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Correlation ID utilities for distributed tracing.
+
+Provides utilities for generating and propagating correlation IDs
+across infrastructure components for distributed tracing and debugging.
+
+Correlation IDs are used to:
+    - Track requests across service boundaries
+    - Link related log entries for debugging
+    - Enable distributed tracing in containerized environments
+    - Provide unique identifiers for error context
+
+Example:
+    >>> from omnibase_infra.utils.correlation import generate_correlation_id
+    >>> correlation_id = generate_correlation_id()
+    >>> logger.info("Processing request", extra={"correlation_id": correlation_id})
+
+Context Manager Example:
+    >>> from omnibase_infra.utils.correlation import CorrelationContext
+    >>> with CorrelationContext() as correlation_id:
+    ...     logger.info("Operation started", extra={"correlation_id": correlation_id})
+    ...     # All operations within this context share the same correlation_id
+"""
+
+from __future__ import annotations
+
+from contextvars import ContextVar, Token
+from typing import TYPE_CHECKING
+from uuid import UUID, uuid4
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+# Context variable for correlation ID propagation across async boundaries
+# This enables correlation ID to be implicitly passed through async call chains
+_correlation_id: ContextVar[UUID | None] = ContextVar("correlation_id", default=None)
+
+
+def generate_correlation_id() -> UUID:
+    """Generate a new correlation ID using UUID4.
+
+    Creates a cryptographically random UUID suitable for distributed tracing.
+    UUID4 is used because it provides high uniqueness guarantees without
+    requiring coordination between nodes.
+
+    Returns:
+        UUID: A new randomly generated UUID4 correlation ID.
+
+    Example:
+        >>> correlation_id = generate_correlation_id()
+        >>> print(correlation_id)
+        123e4567-e89b-12d3-a456-426614174000
+        >>> isinstance(correlation_id, UUID)
+        True
+    """
+    return uuid4()
+
+
+def get_correlation_id() -> UUID:
+    """Get current correlation ID from context or generate new one.
+
+    Retrieves the correlation ID from the current async context. If no
+    correlation ID has been set in the current context, generates a new
+    one and sets it for future retrieval.
+
+    This function is useful when you need a correlation ID but don't know
+    if one has already been established in the current execution context.
+
+    Returns:
+        UUID: Current correlation ID from context, or a new one if not set.
+
+    Example:
+        >>> # First call generates and stores a new ID
+        >>> id1 = get_correlation_id()
+        >>> # Second call returns the same ID
+        >>> id2 = get_correlation_id()
+        >>> id1 == id2
+        True
+    """
+    correlation_id = _correlation_id.get()
+    if correlation_id is None:
+        correlation_id = generate_correlation_id()
+        _correlation_id.set(correlation_id)
+    return correlation_id
+
+
+def set_correlation_id(correlation_id: UUID) -> None:
+    """Set correlation ID in current context.
+
+    Explicitly sets a correlation ID in the current async context. This is
+    useful when you want to propagate an existing correlation ID (e.g., from
+    an incoming request header) into the current execution context.
+
+    Args:
+        correlation_id: The correlation ID to set. Must be a UUID instance.
+
+    Example:
+        >>> incoming_id = UUID("123e4567-e89b-12d3-a456-426614174000")
+        >>> set_correlation_id(incoming_id)
+        >>> get_correlation_id() == incoming_id
+        True
+    """
+    _correlation_id.set(correlation_id)
+
+
+def clear_correlation_id() -> None:
+    """Clear the correlation ID from the current context.
+
+    Resets the correlation ID context variable to None. This is useful
+    when starting a new logical operation that should not inherit the
+    correlation ID from a previous operation.
+
+    Example:
+        >>> set_correlation_id(generate_correlation_id())
+        >>> clear_correlation_id()
+        >>> _correlation_id.get() is None
+        True
+    """
+    _correlation_id.set(None)
+
+
+class CorrelationContext:
+    """Context manager for correlation ID scoping.
+
+    Provides a context manager that automatically generates or uses a provided
+    correlation ID for the duration of the context. The previous correlation ID
+    is restored when exiting the context, enabling nested correlation scopes.
+
+    This is useful for:
+        - Scoping correlation IDs to specific operations
+        - Ensuring cleanup of correlation context
+        - Nested correlation contexts with proper restoration
+
+    Attributes:
+        correlation_id: The correlation ID used within this context.
+
+    Example:
+        >>> with CorrelationContext() as correlation_id:
+        ...     logger.info("Operation", extra={"correlation_id": correlation_id})
+        ...     # correlation_id is available and set in context
+
+    Example with provided ID:
+        >>> existing_id = UUID("123e4567-e89b-12d3-a456-426614174000")
+        >>> with CorrelationContext(correlation_id=existing_id) as cid:
+        ...     cid == existing_id
+        True
+
+    Example with nesting:
+        >>> with CorrelationContext() as outer_id:
+        ...     with CorrelationContext() as inner_id:
+        ...         # inner_id is different from outer_id
+        ...         pass
+        ...     # outer_id is restored after inner context exits
+    """
+
+    def __init__(self, correlation_id: UUID | None = None) -> None:
+        """Initialize the correlation context.
+
+        Args:
+            correlation_id: Optional correlation ID to use. If not provided,
+                a new UUID4 will be generated when entering the context.
+        """
+        self._correlation_id = correlation_id or generate_correlation_id()
+        self._token: Token[UUID | None] | None = None
+
+    @property
+    def correlation_id(self) -> UUID:
+        """Return the correlation ID for this context.
+
+        Returns:
+            UUID: The correlation ID associated with this context.
+        """
+        return self._correlation_id
+
+    def __enter__(self) -> UUID:
+        """Enter the correlation context and set the correlation ID.
+
+        Returns:
+            UUID: The correlation ID for this context.
+        """
+        self._token = _correlation_id.set(self._correlation_id)
+        return self._correlation_id
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the correlation context and restore the previous correlation ID.
+
+        Args:
+            exc_type: Exception type if an exception was raised.
+            exc_val: Exception value if an exception was raised.
+            exc_tb: Traceback if an exception was raised.
+        """
+        if self._token is not None:
+            _correlation_id.reset(self._token)
+
+
+__all__: list[str] = [
+    "CorrelationContext",
+    "clear_correlation_id",
+    "generate_correlation_id",
+    "get_correlation_id",
+    "set_correlation_id",
+]

omnibase_infra/utils/util_atomic_file.py

@@ -0,0 +1,261 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Atomic file write utilities.
+
+This module provides primitives for atomic file writes using the temp-file-rename
+pattern. Atomic writes ensure that file contents are either completely written
+or not written at all - there is no intermediate state where the file contains
+partial data.
+
+POSIX Atomicity Guarantees:
+    On POSIX systems, rename() is atomic within the same filesystem. This module
+    creates the temporary file in the same directory as the target file to ensure
+    the rename operation is atomic.
+
+    **IMPORTANT**: The temp file MUST be created in the same directory as the
+    target file (using `dir=path.parent`). If the temp file is on a different
+    filesystem, the rename becomes a copy-and-delete operation, losing atomicity.
+
+NFS Caveat:
+    NFS provides weaker atomicity guarantees. While rename() is still atomic on
+    NFSv4+, there may be brief windows where both files are visible to other
+    clients. For applications requiring strict consistency on NFS, additional
+    locking mechanisms may be needed.
+
+Windows Notes:
+    - os.replace() is atomic on Windows since Python 3.3
+    - Path.rename() on Windows will fail if the target exists; use os.replace()
+    - This module uses os.replace() for cross-platform atomic rename
+
+Durability Note:
+    This module provides atomicity (all-or-nothing) but not durability guarantees.
+    For systems requiring crash-recovery durability, consider adding fsync() after
+    write and before rename. This comes at a performance cost.
+
+Example:
+    >>> from pathlib import Path
+    >>> from omnibase_infra.utils import write_atomic_bytes
+    >>>
+    >>> # Write data atomically
+    >>> data = b"Hello, World!"
+    >>> bytes_written = write_atomic_bytes(Path("/tmp/myfile.txt"), data)
+    >>> bytes_written
+    13
+    >>>
+    >>> # Async version (uses asyncio.to_thread internally)
+    >>> import asyncio
+    >>> from omnibase_infra.utils import write_atomic_bytes_async
+    >>> bytes_written = asyncio.run(write_atomic_bytes_async(Path("/tmp/myfile.txt"), data))
+    >>> bytes_written
+    13
+
+.. versionadded:: 0.10.0
+    Created as part of OMN-1524 atomic write utilities.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import tempfile
+from pathlib import Path
+from uuid import UUID
+
+logger = logging.getLogger(__name__)
+
+
+def write_atomic_bytes(
+    path: Path,
+    data: bytes,
+    *,
+    temp_prefix: str = "",
+    temp_suffix: str = ".tmp",
+    correlation_id: UUID | None = None,
+) -> int:
+    """Write bytes to a file atomically using temp-file-rename pattern.
+
+    This function provides atomic file writes by:
+    1. Creating a temporary file in the same directory as the target
+    2. Writing all data to the temporary file
+    3. Atomically renaming the temporary file to the target path
+
+    The rename operation is atomic on POSIX systems when both files are on the
+    same filesystem. On Windows, os.replace() provides atomic semantics since
+    Python 3.3.
+
+    Args:
+        path: Target file path. Parent directory must exist.
+        data: Bytes to write to the file.
+        temp_prefix: Optional prefix for the temporary file name. Useful for
+            debugging to identify the source of temp files.
+        temp_suffix: Suffix for the temporary file name. Defaults to ".tmp".
+        correlation_id: Optional correlation ID for ONEX logging. When provided,
+            errors are logged with correlation context before being raised.
+
+    Returns:
+        Number of bytes written to the file.
+
+    Raises:
+        InfraConnectionError: If the file cannot be written (permissions, disk full,
+            etc.). The underlying OSError is chained via ``from e``. The temporary
+            file is cleaned up before raising.
+
+    Example:
+        >>> from pathlib import Path
+        >>> from omnibase_infra.utils.util_atomic_file import write_atomic_bytes
+        >>>
+        >>> # Basic atomic write
+        >>> path = Path("/tmp/test_atomic.txt")
+        >>> bytes_written = write_atomic_bytes(path, b"test data")
+        >>> bytes_written
+        9
+        >>>
+        >>> # With debugging prefix
+        >>> bytes_written = write_atomic_bytes(
+        ...     path,
+        ...     b"test data",
+        ...     temp_prefix="manifest_",
+        ...     correlation_id=UUID("12345678-1234-5678-1234-567812345678"),
+        ... )
+
+    Warning:
+        The parent directory of ``path`` must exist. This function does not
+        create parent directories.
+
+    Warning:
+        On NFS, atomicity guarantees are weaker. See module docstring for details.
+
+    Related:
+        - handler_manifest_persistence.py: Original pattern implementation
+    """
+    temp_fd: int | None = None
+    temp_path: str | None = None
+
+    try:
+        # Create temp file in same directory for atomic rename guarantee
+        temp_fd, temp_path = tempfile.mkstemp(
+            suffix=temp_suffix,
+            prefix=temp_prefix,
+            dir=path.parent,
+        )
+
+        # Write data to temp file
+        with os.fdopen(temp_fd, "wb") as f:
+            temp_fd = None  # fdopen takes ownership of fd
+            bytes_written = f.write(data)
+
+        # Atomic rename (Path.replace is atomic on both POSIX and Windows 3.3+)
+        Path(temp_path).replace(path)
+        temp_path = None  # Rename succeeded, no cleanup needed
+
+        return bytes_written
+
+    except OSError as e:
+        # Log with correlation context if provided
+        if correlation_id is not None:
+            logger.exception(
+                "Atomic write failed for '%s'",
+                path,
+                extra={
+                    "correlation_id": str(correlation_id),
+                    "target_path": str(path),
+                    "temp_prefix": temp_prefix,
+                    "temp_suffix": temp_suffix,
+                    "error_type": type(e).__name__,
+                },
+            )
+
+        # Cleanup: close fd if fdopen didn't take ownership
+        if temp_fd is not None:
+            try:
+                os.close(temp_fd)
+            except OSError:
+                pass  # Best effort cleanup
+
+        # Cleanup: remove temp file if it exists
+        if temp_path is not None:
+            try:
+                Path(temp_path).unlink(missing_ok=True)
+            except OSError:
+                pass  # Best effort cleanup
+
+        # Wrap OSError in InfraConnectionError per ONEX error handling guidelines
+        # Deferred import to avoid circular dependency (utils -> errors -> utils)
+        from omnibase_infra.enums import EnumInfraTransportType
+        from omnibase_infra.errors import InfraConnectionError, ModelInfraErrorContext
+
+        context = ModelInfraErrorContext.with_correlation(
+            correlation_id=correlation_id,
+            transport_type=EnumInfraTransportType.FILESYSTEM,
+            operation="write_atomic_bytes",
+            target_name=str(path),
+        )
+        raise InfraConnectionError(
+            f"Atomic write failed for '{path}'",
+            context=context,
+            error_type=type(e).__name__,
+            errno=getattr(e, "errno", None),
+        ) from e
+
+
+async def write_atomic_bytes_async(
+    path: Path,
+    data: bytes,
+    *,
+    temp_prefix: str = "",
+    temp_suffix: str = ".tmp",
+    correlation_id: UUID | None = None,
+) -> int:
+    """Write bytes to a file atomically (async version).
+
+    This is a thin async wrapper around :func:`write_atomic_bytes` that uses
+    ``asyncio.to_thread()`` to run the synchronous implementation in a thread
+    pool. This prevents blocking the event loop during file I/O.
+
+    All logic is delegated to :func:`write_atomic_bytes` - this function exists
+    only to provide an async interface.
+
+    Args:
+        path: Target file path. Parent directory must exist.
+        data: Bytes to write to the file.
+        temp_prefix: Optional prefix for the temporary file name.
+        temp_suffix: Suffix for the temporary file name. Defaults to ".tmp".
+        correlation_id: Optional correlation ID for ONEX logging.
+
+    Returns:
+        Number of bytes written to the file.
+
+    Raises:
+        InfraConnectionError: If the file cannot be written (permissions, disk full,
+            etc.). The underlying OSError is chained via ``from e``.
+
+    Example:
+        >>> import asyncio
+        >>> from pathlib import Path
+        >>> from omnibase_infra.utils.util_atomic_file import write_atomic_bytes_async
+        >>>
+        >>> async def example():
+        ...     path = Path("/tmp/test_async.txt")
+        ...     return await write_atomic_bytes_async(path, b"async data")
+        >>>
+        >>> asyncio.run(example())
+        10
+
+    See Also:
+        :func:`write_atomic_bytes`: The synchronous canonical implementation.
+    """
+    return await asyncio.to_thread(
+        write_atomic_bytes,
+        path,
+        data,
+        temp_prefix=temp_prefix,
+        temp_suffix=temp_suffix,
+        correlation_id=correlation_id,
+    )
+
+
+__all__: list[str] = [
+    "write_atomic_bytes",
+    "write_atomic_bytes_async",
+]

omnibase_infra/utils/util_consumer_group.py

@@ -0,0 +1,232 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2025 OmniNode Team
+"""Kafka consumer group ID utilities.
+
+Provides utilities for normalizing and validating Kafka consumer group identifiers.
+Kafka consumer group IDs have specific character and length constraints that this
+module helps enforce consistently across the codebase.
+
+Kafka Consumer Group ID Constraints:
+    - Maximum length: 255 characters
+    - Valid characters: alphanumeric, period (.), underscore (_), hyphen (-)
+    - Cannot be empty
+
+This module provides:
+    - normalize_kafka_identifier: Normalize strings for use as Kafka consumer group IDs
+    - compute_consumer_group_id: Compute canonical consumer group ID from node identity
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from typing import TYPE_CHECKING
+
+from omnibase_infra.enums import EnumConsumerGroupPurpose
+
+if TYPE_CHECKING:
+    from omnibase_infra.models import ModelNodeIdentity
+
+# Maximum length for Kafka consumer group IDs
+KAFKA_CONSUMER_GROUP_MAX_LENGTH = 255
+
+# Pattern for invalid characters (anything not alphanumeric, period, underscore, or hyphen)
+_INVALID_CHAR_PATTERN = re.compile(r"[^a-z0-9._-]")
+
+# Pattern for consecutive separators (period, underscore, or hyphen)
+_CONSECUTIVE_SEPARATOR_PATTERN = re.compile(r"[._-]{2,}")
+
+# Pattern for leading/trailing separators
+_EDGE_SEPARATOR_PATTERN = re.compile(r"^[._-]+|[._-]+$")
+
+
+def normalize_kafka_identifier(value: str) -> str:
+    """Normalize a string for use as a Kafka consumer group ID.
+
+    Applies the following transformations in order:
+        1. Convert to lowercase
+        2. Replace invalid characters (non-alphanumeric, non-separator) with underscore
+        3. Collapse consecutive separators (., _, -) into a single separator
+        4. Strip leading and trailing separators
+        5. Truncate to max length (255) with hash suffix if necessary
+
+    The hash suffix ensures uniqueness when truncation is required. The suffix
+    format is `_<8-char-hash>` appended after truncating to fit within 255 chars.
+
+    Args:
+        value: The input string to normalize.
+
+    Returns:
+        A normalized string safe for use as a Kafka consumer group ID.
+
+    Raises:
+        ValueError: If the input is empty or results in an empty string after
+            normalization.
+
+    Example:
+        >>> normalize_kafka_identifier("My Service!!")
+        'my_service'
+        >>> normalize_kafka_identifier("foo..bar__baz")
+        'foo.bar_baz'
+        >>> normalize_kafka_identifier("  UPPER_Case-Test  ")
+        'upper_case-test'
+        >>> normalize_kafka_identifier("valid.consumer-group_id")
+        'valid.consumer-group_id'
+        >>> normalize_kafka_identifier("@#$%^&*()")  # Raises ValueError
+        Traceback (most recent call last):
+            ...
+        ValueError: Input '@#$%^&*()' results in empty string after normalization
+    """
+    if not value:
+        raise ValueError("Kafka consumer group ID cannot be empty")
+
+    # Step 1: Lowercase
+    result = value.lower()
+
+    # Step 2: Replace invalid characters with underscore
+    result = _INVALID_CHAR_PATTERN.sub("_", result)
+
+    # Step 3: Collapse consecutive separators, preserving the first separator type
+    result = _CONSECUTIVE_SEPARATOR_PATTERN.sub(lambda m: m.group(0)[0], result)
+
+    # Step 4: Strip leading and trailing separators
+    result = _EDGE_SEPARATOR_PATTERN.sub("", result)
+
+    # Check for empty result after normalization
+    if not result:
+        raise ValueError(f"Input {value!r} results in empty string after normalization")
+
+    # Step 5: Truncate with hash suffix if exceeds max length
+    if len(result) > KAFKA_CONSUMER_GROUP_MAX_LENGTH:
+        # Generate 8-character hash suffix from original value for determinism
+        hash_suffix = hashlib.sha256(value.encode()).hexdigest()[:8]
+        # Reserve space for underscore + hash suffix (9 chars total)
+        max_prefix_length = KAFKA_CONSUMER_GROUP_MAX_LENGTH - 9
+        result = f"{result[:max_prefix_length]}_{hash_suffix}"
+
+    return result
+
+
+def compute_consumer_group_id(
+    identity: ModelNodeIdentity,
+    purpose: EnumConsumerGroupPurpose = EnumConsumerGroupPurpose.CONSUME,
+) -> str:
+    """Compute canonical Kafka consumer group ID from node identity.
+
+    Generates a deterministic, Kafka-compliant consumer group ID using the
+    canonical format: ``{env}.{service}.{node_name}.{purpose}.{version}``
+
+    Each component is normalized using ``normalize_kafka_identifier()`` to ensure
+    the result is safe for use as a Kafka consumer group ID. The final result
+    is validated against Kafka's 255 character limit.
+
+    Args:
+        identity: Node identity containing env, service, node_name, and version.
+        purpose: Consumer group purpose classification. Defaults to CONSUME.
+            The purpose determines consumer behavior semantics (e.g., offset
+            reset policy) and is included in the group ID for disambiguation.
+
+    Returns:
+        A canonical consumer group ID in the format:
+        ``{env}.{service}.{node_name}.{purpose}.{version}``
+
+        If the combined length exceeds Kafka's 255 character limit, the result
+        is truncated with an 8-character hash suffix to preserve uniqueness
+        while fitting within the constraint.
+
+    Example:
+        >>> from omnibase_infra.models import ModelNodeIdentity
+        >>> from omnibase_infra.enums import EnumConsumerGroupPurpose
+        >>> identity = ModelNodeIdentity(
+        ...     env="dev",
+        ...     service="omniintelligence",
+        ...     node_name="claude_hook_event_effect",
+        ...     version="v1",
+        ... )
+        >>> compute_consumer_group_id(identity)
+        'dev.omniintelligence.claude_hook_event_effect.consume.v1'
+
+        With a different purpose:
+
+        >>> compute_consumer_group_id(identity, EnumConsumerGroupPurpose.INTROSPECTION)
+        'dev.omniintelligence.claude_hook_event_effect.introspection.v1'
+
+        Component normalization is applied automatically:
+
+        >>> identity_mixed = ModelNodeIdentity(
+        ...     env="DEV",
+        ...     service="Omni Intelligence",
+        ...     node_name="claude-hook-event-effect",
+        ...     version="V1.0.0",
+        ... )
+        >>> compute_consumer_group_id(identity_mixed)
+        'dev.omni_intelligence.claude-hook-event-effect.consume.v1.0.0'
+
+        Long identities are automatically truncated with a hash suffix:
+
+        >>> long_identity = ModelNodeIdentity(
+        ...     env="development",
+        ...     service="a" * 100,
+        ...     node_name="b" * 100,
+        ...     version="v1",
+        ... )
+        >>> result = compute_consumer_group_id(long_identity)
+        >>> len(result) <= 255
+        True
+        >>> result.endswith("_" + result[-8:])  # Has hash suffix
+        True
+
+    Note:
+        The canonical format uses period (.) as the separator between components.
+        This enables hierarchical grouping and filtering in Kafka tooling while
+        maintaining compatibility with Kafka's consumer group ID constraints.
+
+    See Also:
+        - :func:`normalize_kafka_identifier`: Component normalization rules
+        - :class:`~omnibase_infra.enums.EnumConsumerGroupPurpose`: Purpose values
+        - :class:`~omnibase_infra.models.ModelNodeIdentity`: Identity model
+
+    .. versionadded:: 0.2.6
+        Created as part of OMN-1602.
+    """
+    # Normalize each component
+    normalized_env = normalize_kafka_identifier(identity.env)
+    normalized_service = normalize_kafka_identifier(identity.service)
+    normalized_node_name = normalize_kafka_identifier(identity.node_name)
+    normalized_purpose = normalize_kafka_identifier(purpose.value)
+    normalized_version = normalize_kafka_identifier(identity.version)
+
+    # Join with period separator
+    group_id = ".".join(
+        [
+            normalized_env,
+            normalized_service,
+            normalized_node_name,
+            normalized_purpose,
+            normalized_version,
+        ]
+    )
+
+    # Handle length constraint with truncation + hash (same strategy as normalize_kafka_identifier)
+    # This can occur when multiple long components combine, even though each was individually
+    # truncated to 255 chars by normalize_kafka_identifier.
+    if len(group_id) > KAFKA_CONSUMER_GROUP_MAX_LENGTH:
+        # Generate deterministic hash from original (pre-normalized) identity components
+        # to ensure the same identity always produces the same truncated group ID
+        hash_input = (
+            f"{identity.env}|{identity.service}|{identity.node_name}|"
+            f"{purpose.value}|{identity.version}"
+        )
+        hash_suffix = hashlib.sha256(hash_input.encode()).hexdigest()[:8]
+        # Reserve space for underscore + hash suffix (9 chars total)
+        max_prefix_length = KAFKA_CONSUMER_GROUP_MAX_LENGTH - 9
+        group_id = f"{group_id[:max_prefix_length]}_{hash_suffix}"
+
+    return group_id
+
+
+__all__: list[str] = [
+    "KAFKA_CONSUMER_GROUP_MAX_LENGTH",
+    "compute_consumer_group_id",
+    "normalize_kafka_identifier",
+]