python-etcd3-async 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

etcd3/async_client_extensions.py

@@ -67,32 +67,32 @@ def _manage_client_errors(self, exc):
 
 def _set_span_attributes_from_response(response, endpoint: str = None):
     """Set span attributes from etcd response.
-    
+
     :param response: etcd response object
     :param endpoint: Optional endpoint string
     """
     if not is_tracing_available():
         return
-    
+
     span = get_current_span()
     if span is None:
         return
-    
+
     # Build attributes from response
-    attrs = build_response_attributes(header=getattr(response, 'header', None))
-    
+    attrs = build_response_attributes(header=getattr(response, "header", None))
+
     # Add count if available
-    if hasattr(response, 'count'):
+    if hasattr(response, "count"):
         attrs[TraceAttributes.ETCD_COUNT] = response.count
-    
+
     # Add deleted if available
-    if hasattr(response, 'deleted'):
+    if hasattr(response, "deleted"):
         attrs[TraceAttributes.ETCD_DELETED] = response.deleted
-    
+
     # Add endpoint if provided
     if endpoint:
         attrs[TraceAttributes.ETCD_ENDPOINT] = endpoint
-    
+
     # Set attributes on span
     for key, value in attrs.items():
         if value is not None:
@@ -147,11 +147,13 @@ class AsyncKVOperations:
             credentials=self.client.call_credentials,
             metadata=self.client.metadata,
         )
-        
+
         # Set trace attributes from response
-        endpoint = str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+        endpoint = (
+            str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+        )
         _set_span_attributes_from_response(response, endpoint)
-        
+
         return response
 
     async def get(self, key, **kwargs):
@@ -259,9 +261,11 @@ class AsyncKVOperations:
             credentials=self.client.call_credentials,
             metadata=self.client.metadata,
         )
-        
+
         # Set trace attributes from response
-        endpoint = str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+        endpoint = (
+            str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+        )
         _set_span_attributes_from_response(put_response, endpoint)
 
         if prev_kv:
@@ -317,9 +321,11 @@ class AsyncKVOperations:
             credentials=self.client.call_credentials,
             metadata=self.client.metadata,
         )
-        
+
         # Set trace attributes from response
-        endpoint = str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+        endpoint = (
+            str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+        )
         _set_span_attributes_from_response(delete_response, endpoint)
 
         if return_response:
@@ -391,7 +397,9 @@ class AsyncKVOperations:
             except Exception as exc:
                 if isinstance(exc, exceptions.BatchOperationError):
                     raise
-                raise exceptions.BatchOperationError(f"Batch put failed: {exc}") from exc
+                raise exceptions.BatchOperationError(
+                    f"Batch put failed: {exc}"
+                ) from exc
         else:
             # Non-atomic: parallel execution with concurrency control
             semaphore = asyncio.Semaphore(concurrency)
@@ -456,7 +464,9 @@ class AsyncKVOperations:
             except Exception as exc:
                 if isinstance(exc, exceptions.BatchOperationError):
                     raise
-                raise exceptions.BatchOperationError(f"Batch delete failed: {exc}") from exc
+                raise exceptions.BatchOperationError(
+                    f"Batch delete failed: {exc}"
+                ) from exc
         else:
             # Non-atomic: parallel execution with concurrency control
             semaphore = asyncio.Semaphore(concurrency)
@@ -537,21 +547,24 @@ class AsyncLeaseOperations:
             credentials=self.client.call_credentials,
             metadata=self.client.metadata,
         )
-        
+
         # Set trace attributes for lease
         if is_tracing_available():
             span = get_current_span()
             if span:
                 attrs = build_lease_attributes(
-                    lease_id=lease_grant_response.ID,
-                    ttl=lease_grant_response.TTL
+                    lease_id=lease_grant_response.ID, ttl=lease_grant_response.TTL
+                )
+                endpoint = (
+                    str(self.client.endpoint_in_use)
+                    if self.client.endpoint_in_use
+                    else None
                 )
-                endpoint = str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
                 if endpoint:
                     attrs[TraceAttributes.ETCD_ENDPOINT] = endpoint
                 for key, value in attrs.items():
                     span.set_attribute(key, value)
-        
+
         return AsyncLease(
             lease_id=lease_grant_response.ID,
             ttl=lease_grant_response.TTL,
@@ -569,13 +582,17 @@ class AsyncLeaseOperations:
             credentials=self.client.call_credentials,
             metadata=self.client.metadata,
         )
-        
+
         # Set trace attributes for lease revocation
         if is_tracing_available():
             span = get_current_span()
             if span:
                 attrs = build_lease_attributes(lease_id=lease_id)
-                endpoint = str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
+                endpoint = (
+                    str(self.client.endpoint_in_use)
+                    if self.client.endpoint_in_use
+                    else None
+                )
                 if endpoint:
                     attrs[TraceAttributes.ETCD_ENDPOINT] = endpoint
                 for key, value in attrs.items():
@@ -646,7 +663,7 @@ class AsyncLeaseOperations:
                     # Exponential backoff with jitter
                     retry_delay = min(
                         base_retry_delay * (2 ** (consecutive_errors - 1)),
-                        max_retry_delay
+                        max_retry_delay,
                     )
                     jitter = random.uniform(0, retry_delay * 0.1)
                     actual_delay = retry_delay + jitter
@@ -677,7 +694,7 @@ class AsyncLeaseOperations:
             credentials=self.client.call_credentials,
             metadata=self.client.metadata,
         )
-        
+
         # Set trace attributes for lease info
         if is_tracing_available():
             span = get_current_span()
@@ -685,15 +702,19 @@ class AsyncLeaseOperations:
                 attrs = build_lease_attributes(
                     lease_id=lease_id,
                     ttl=lease_timing_response.TTL,
-                    remaining_ttl=getattr(lease_timing_response, 'TTL', None)
+                    remaining_ttl=getattr(lease_timing_response, "TTL", None),
+                )
+                endpoint = (
+                    str(self.client.endpoint_in_use)
+                    if self.client.endpoint_in_use
+                    else None
                 )
-                endpoint = str(self.client.endpoint_in_use) if self.client.endpoint_in_use else None
                 if endpoint:
                     attrs[TraceAttributes.ETCD_ENDPOINT] = endpoint
                 for key, value in attrs.items():
                     if value is not None:
                         span.set_attribute(key, value)
-        
+
         return lease_timing_response
 
 

etcd3/exceptions.py

@@ -39,9 +39,11 @@ class NoServerAvailableError(Etcd3Exception):
 
 class LockReleaseError(Etcd3Exception):
     """Raised when a lock release operation fails."""
+
     pass
 
 
 class BatchOperationError(Etcd3Exception):
     """Raised when a batch operation fails."""
+
     pass

etcd3/locks.py

@@ -88,7 +88,9 @@ class Lock(object):
             success, metadata = self.etcd_client.transaction(
                 compare=[self.etcd_client.transactions.create(self.key) == 0],
                 success=[
-                    self.etcd_client.transactions.put(self.key, self.uuid, lease=self.lease)
+                    self.etcd_client.transactions.put(
+                        self.key, self.uuid, lease=self.lease
+                    )
                 ],
                 failure=[self.etcd_client.transactions.get(self.key)],
             )
@@ -189,7 +191,7 @@ class Lock(object):
             )
 
             if success:
-                return 'released'
+                return "released"
 
             # Transaction succeeded but comparison failed
             # Check if key exists and who owns it
@@ -200,26 +202,28 @@ class Lock(object):
                         raise exceptions.LockReleaseError(
                             "Lock key does not exist - may have expired or been released"
                         )
-                    return 'not_found'
+                    return "not_found"
                 if current_value != self.uuid:
                     if raise_error:
                         raise exceptions.LockReleaseError(
                             "Lock is held by another owner - cannot release"
                         )
-                    return 'not_owner'
+                    return "not_owner"
 
             if raise_error:
                 raise exceptions.LockReleaseError("Unknown lock release failure")
-            return 'error'
+            return "error"
 
         except exceptions.Etcd3Exception:
             if raise_error:
                 raise
-            return 'error'
+            return "error"
         except Exception as exc:
             if raise_error:
-                raise exceptions.LockReleaseError(f"Lock release failed: {exc}") from exc
-            return 'error'
+                raise exceptions.LockReleaseError(
+                    f"Lock release failed: {exc}"
+                ) from exc
+            return "error"
 
     def refresh(self):
         """Refresh the time to live on this lock."""
@@ -315,22 +319,24 @@ class AsyncLock(object):
 
     def _set_lock_span_attributes(self, acquired: bool = None):
         """Set lock-related attributes on current span.
-        
+
         :param acquired: Whether the lock was acquired (optional)
         """
         if not is_tracing_available():
             return
-        
+
         span = get_current_span()
         if span is None:
             return
-        
+
         attrs = build_lock_attributes(
-            name=self.key if isinstance(self.key, str) else self.key.decode('utf-8', errors='replace'),
+            name=self.key
+            if isinstance(self.key, str)
+            else self.key.decode("utf-8", errors="replace"),
             uuid=self.uuid,
-            acquired=acquired
+            acquired=acquired,
         )
-        
+
         for key, value in attrs.items():
             if value is not None:
                 span.set_attribute(key, value)
@@ -345,7 +351,9 @@ class AsyncLock(object):
             success, metadata = await self.etcd_client.transaction(
                 compare=[self.etcd_client.transactions.create(self.key) == 0],
                 success=[
-                    self.etcd_client.transactions.put(self.key, self.uuid, lease=self.lease)
+                    self.etcd_client.transactions.put(
+                        self.key, self.uuid, lease=self.lease
+                    )
                 ],
                 failure=[self.etcd_client.transactions.get(self.key)],
             )
@@ -450,7 +458,7 @@ class AsyncLock(object):
 
             if success:
                 self._set_lock_span_attributes(acquired=False)
-                return 'released'
+                return "released"
 
             # Transaction succeeded but comparison failed
             # Check if key exists and who owns it
@@ -462,29 +470,31 @@ class AsyncLock(object):
                         raise exceptions.LockReleaseError(
                             "Lock key does not exist - may have expired or been released"
                         )
-                    return 'not_found'
+                    return "not_found"
                 if current_value != self.uuid:
                     self._set_lock_span_attributes(acquired=None)  # Owned by another
                     if raise_error:
                         raise exceptions.LockReleaseError(
                             "Lock is held by another owner - cannot release"
                         )
-                    return 'not_owner'
+                    return "not_owner"
 
             self._set_lock_span_attributes(acquired=None)
             if raise_error:
                 raise exceptions.LockReleaseError("Unknown lock release failure")
-            return 'error'
+            return "error"
 
         except exceptions.Etcd3Exception:
             self._set_lock_span_attributes(acquired=None)
             if raise_error:
                 raise
-            return 'error'
+            return "error"
         except Exception as exc:
             if raise_error:
-                raise exceptions.LockReleaseError(f"Lock release failed: {exc}") from exc
-            return 'error'
+                raise exceptions.LockReleaseError(
+                    f"Lock release failed: {exc}"
+                ) from exc
+            return "error"
 
     def refresh(self):
         """Refresh the time to lease on this lock.
@@ -540,9 +550,7 @@ class AsyncLock(object):
                     refresh_gen = self.refresh()
                     # Get one response from the generator to trigger keepalive
                     try:
-                        await asyncio.wait_for(
-                            refresh_gen.__anext__(), timeout=5.0
-                        )
+                        await asyncio.wait_for(refresh_gen.__anext__(), timeout=5.0)
                         # Successfully refreshed
                     except StopAsyncIteration:
                         # Generator ended unexpectedly

etcd3/trace_attributes.py

@@ -12,35 +12,35 @@ from typing import Any, Dict, Optional
 
 class EtcdOperationType(Enum):
     """etcd operation types for tracing."""
-    
+
     # KV operations
     KV_GET = "kv.get"
     KV_PUT = "kv.put"
     KV_DELETE = "kv.delete"
     KV_RANGE = "kv.range"
     KV_TXN = "kv.transaction"
-    
+
     # Lease operations
     LEASE_GRANT = "lease.grant"
     LEASE_REVOKE = "lease.revoke"
     LEASE_KEEPALIVE = "lease.keepalive"
     LEASE_TTL = "lease.ttl"
-    
+
     # Lock operations
     LOCK_ACQUIRE = "lock.acquire"
     LOCK_RELEASE = "lock.release"
     LOCK_REFRESH = "lock.refresh"
-    
+
     # Watch operations
     WATCH_CREATE = "watch.create"
     WATCH_CANCEL = "watch.cancel"
-    
+
     # Cluster operations
     CLUSTER_MEMBER_ADD = "cluster.member.add"
     CLUSTER_MEMBER_REMOVE = "cluster.member.remove"
     CLUSTER_MEMBER_UPDATE = "cluster.member.update"
     CLUSTER_MEMBER_LIST = "cluster.member.list"
-    
+
     # Maintenance operations
     MAINTENANCE_STATUS = "maintenance.status"
     MAINTENANCE_COMPACT = "maintenance.compact"
@@ -50,126 +50,126 @@ class EtcdOperationType(Enum):
 @dataclass(frozen=True)
 class TraceAttributes:
     """Standard attribute names for etcd OpenTelemetry traces.
-    
+
     These attributes follow OpenTelemetry semantic conventions where applicable
     and define etcd-specific attributes for comprehensive observability.
     """
-    
+
     # === OpenTelemetry Standard Database Attributes ===
     DB_SYSTEM = "db.system"
     """Database system: always 'etcd' for this client."""
-    
+
     DB_OPERATION = "db.operation"
     """Database operation name (e.g., 'kv.get', 'lease.grant')."""
-    
+
     DB_STATEMENT = "db.statement"
     """Database statement (for complex queries, optional)."""
-    
+
     # === etcd Key-Value Attributes ===
     ETCD_KEY = "etcd.key"
     """The key being operated on."""
-    
+
     ETCD_RANGE_END = "etcd.range_end"
     """End of the key range for range operations."""
-    
+
     ETCD_LIMIT = "etcd.limit"
     """Maximum number of keys to return."""
-    
+
     ETCD_REVISION = "etcd.revision"
     """Current revision of the operation result."""
-    
+
     ETCD_PREV_REVISION = "etcd.prev_revision"
     """Previous revision (for compare operations)."""
-    
+
     ETCD_COUNT = "etcd.count"
     """Number of keys returned or affected."""
-    
+
     ETCD_DELETED = "etcd.deleted"
     """Number of keys deleted."""
-    
+
     # === etcd Cluster Attributes ===
     ETCD_ENDPOINT = "etcd.endpoint"
     """The etcd endpoint being accessed."""
-    
+
     ETCD_CLUSTER_ID = "etcd.cluster_id"
     """Cluster ID from response header."""
-    
+
     ETCD_MEMBER_ID = "etcd.member_id"
     """Member ID from response header."""
-    
+
     ETCD_RAFT_TERM = "etcd.raft_term"
     """Raft term from response header."""
-    
+
     # === etcd Lease Attributes ===
     ETCD_LEASE_ID = "etcd.lease.id"
     """Lease ID."""
-    
+
     ETCD_LEASE_TTL = "etcd.lease.ttl"
     """Lease TTL in seconds."""
-    
+
     ETCD_LEASE_REMAINING_TTL = "etcd.lease.remaining_ttl"
     """Remaining TTL for the lease."""
-    
+
     # === etcd Lock Attributes ===
     ETCD_LOCK_NAME = "etcd.lock.name"
     """Lock name (key path)."""
-    
+
     ETCD_LOCK_UUID = "etcd.lock.uuid"
     """Lock UUID (first 8 bytes)."""
-    
+
     ETCD_LOCK_ACQUIRED = "etcd.lock.acquired"
     """Whether the lock was successfully acquired."""
-    
+
     # === etcd Transaction Attributes ===
     ETCD_TXN_COMPARE_COUNT = "etcd.txn.compare_count"
     """Number of compare conditions."""
-    
+
     ETCD_TXN_SUCCESS_COUNT = "etcd.txn.success_count"
     """Number of success operations."""
-    
+
     ETCD_TXN_FAILURE_COUNT = "etcd.txn.failure_count"
     """Number of failure operations."""
-    
+
     ETCD_TXN_SUCCEEDED = "etcd.txn.succeeded"
     """Whether the transaction succeeded."""
-    
+
     # === etcd Batch Attributes ===
     ETCD_BATCH_SIZE = "etcd.batch.size"
     """Number of operations in the batch."""
-    
+
     ETCD_BATCH_ATOMIC = "etcd.batch.atomic"
     """Whether the batch is atomic."""
-    
+
     # === etcd Error Attributes ===
     ETCD_ERROR_CODE = "etcd.error_code"
     """Error code if operation failed."""
-    
+
     ETCD_ERROR_MESSAGE = "etcd.error_message"
     """Error message if operation failed."""
-    
+
     # === Retry Attributes ===
     ETCD_RETRY_COUNT = "etcd.retry.count"
     """Number of retries for this operation."""
-    
+
     ETCD_RETRY_ENDPOINT = "etcd.retry.endpoint"
     """Endpoint used after retry."""
 
 
 def _safe_decode(value: Optional[bytes], max_length: int = 256) -> Optional[str]:
     """Safely decode bytes to string for attribute values.
-    
+
     Args:
         value: Bytes value to decode
         max_length: Maximum length for the decoded string
-        
+
     Returns:
         Decoded string or None if input is None
     """
     if value is None:
         return None
-    
+
     try:
-        decoded = value.decode('utf-8', errors='replace')
+        decoded = value.decode("utf-8", errors="replace")
         if len(decoded) > max_length:
             decoded = decoded[:max_length] + "..."
         return decoded
@@ -182,17 +182,17 @@ def build_kv_attributes(
     key: Optional[bytes] = None,
     range_end: Optional[bytes] = None,
     limit: Optional[int] = None,
-    **kwargs
+    **kwargs,
 ) -> Dict[str, Any]:
     """Build trace attributes for KV operations.
-    
+
     Args:
         operation: Operation type (e.g., 'kv.get', 'kv.put')
         key: The key being operated on
         range_end: End of key range for range operations
         limit: Maximum number of keys to return
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
@@ -200,51 +200,48 @@ def build_kv_attributes(
         TraceAttributes.DB_SYSTEM: "etcd",
         TraceAttributes.DB_OPERATION: operation,
     }
-    
+
     if key is not None:
         attrs[TraceAttributes.ETCD_KEY] = _safe_decode(key)
-    
+
     if range_end is not None:
         attrs[TraceAttributes.ETCD_RANGE_END] = _safe_decode(range_end)
-    
+
     if limit is not None:
         attrs[TraceAttributes.ETCD_LIMIT] = limit
-    
+
     attrs.update(kwargs)
     return attrs
 
 
 def build_response_attributes(
-    header=None,
-    count: Optional[int] = None,
-    deleted: Optional[int] = None,
-    **kwargs
+    header=None, count: Optional[int] = None, deleted: Optional[int] = None, **kwargs
 ) -> Dict[str, Any]:
     """Build trace attributes from etcd response.
-    
+
     Args:
         header: Response header from etcd
         count: Number of keys returned/affected
         deleted: Number of keys deleted
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
     attrs = {}
-    
+
     if header:
         attrs[TraceAttributes.ETCD_REVISION] = header.revision
         attrs[TraceAttributes.ETCD_CLUSTER_ID] = header.cluster_id
         attrs[TraceAttributes.ETCD_MEMBER_ID] = header.member_id
         attrs[TraceAttributes.ETCD_RAFT_TERM] = header.raft_term
-    
+
     if count is not None:
         attrs[TraceAttributes.ETCD_COUNT] = count
-    
+
     if deleted is not None:
         attrs[TraceAttributes.ETCD_DELETED] = deleted
-    
+
     attrs.update(kwargs)
     return attrs
 
@@ -253,32 +250,32 @@ def build_lease_attributes(
     lease_id: Optional[int] = None,
     ttl: Optional[int] = None,
     remaining_ttl: Optional[int] = None,
-    **kwargs
+    **kwargs,
 ) -> Dict[str, Any]:
     """Build trace attributes for lease operations.
-    
+
     Args:
         lease_id: Lease ID
         ttl: Lease TTL in seconds
         remaining_ttl: Remaining TTL
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
     attrs = {
         TraceAttributes.DB_SYSTEM: "etcd",
     }
-    
+
     if lease_id is not None:
         attrs[TraceAttributes.ETCD_LEASE_ID] = lease_id
-    
+
     if ttl is not None:
         attrs[TraceAttributes.ETCD_LEASE_TTL] = ttl
-    
+
     if remaining_ttl is not None:
         attrs[TraceAttributes.ETCD_LEASE_REMAINING_TTL] = remaining_ttl
-    
+
     attrs.update(kwargs)
     return attrs
 
@@ -287,34 +284,34 @@ def build_lock_attributes(
     name: Optional[str] = None,
     uuid: Optional[bytes] = None,
     acquired: Optional[bool] = None,
-    **kwargs
+    **kwargs,
 ) -> Dict[str, Any]:
     """Build trace attributes for lock operations.
-    
+
     Args:
         name: Lock name (key path)
         uuid: Lock UUID (will use first 8 bytes)
         acquired: Whether the lock was acquired
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
     attrs = {
         TraceAttributes.DB_SYSTEM: "etcd",
     }
-    
+
     if name is not None:
         attrs[TraceAttributes.ETCD_LOCK_NAME] = name
-    
+
     if uuid is not None:
         # Use first 8 bytes of UUID for readability
         uuid_str = uuid[:8].hex() if isinstance(uuid, bytes) else str(uuid)[:16]
         attrs[TraceAttributes.ETCD_LOCK_UUID] = uuid_str
-    
+
     if acquired is not None:
         attrs[TraceAttributes.ETCD_LOCK_ACQUIRED] = acquired
-    
+
     attrs.update(kwargs)
     return attrs
 
@@ -324,52 +321,48 @@ def build_txn_attributes(
     success_count: Optional[int] = None,
     failure_count: Optional[int] = None,
     succeeded: Optional[bool] = None,
-    **kwargs
+    **kwargs,
 ) -> Dict[str, Any]:
     """Build trace attributes for transaction operations.
-    
+
     Args:
         compare_count: Number of compare conditions
         success_count: Number of success operations
         failure_count: Number of failure operations
         succeeded: Whether the transaction succeeded
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
     attrs = {
         TraceAttributes.DB_SYSTEM: "etcd",
     }
-    
+
     if compare_count is not None:
         attrs[TraceAttributes.ETCD_TXN_COMPARE_COUNT] = compare_count
-    
+
     if success_count is not None:
         attrs[TraceAttributes.ETCD_TXN_SUCCESS_COUNT] = success_count
-    
+
     if failure_count is not None:
         attrs[TraceAttributes.ETCD_TXN_FAILURE_COUNT] = failure_count
-    
+
     if succeeded is not None:
         attrs[TraceAttributes.ETCD_TXN_SUCCEEDED] = succeeded
-    
+
     attrs.update(kwargs)
     return attrs
 
 
-def build_batch_attributes(
-    size: int,
-    atomic: bool = False,
-    **kwargs
-) -> Dict[str, Any]:
+def build_batch_attributes(size: int, atomic: bool = False, **kwargs) -> Dict[str, Any]:
     """Build trace attributes for batch operations.
-    
+
     Args:
         size: Number of operations in the batch
         atomic: Whether the batch is atomic
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
@@ -378,57 +371,52 @@ def build_batch_attributes(
         TraceAttributes.ETCD_BATCH_SIZE: size,
         TraceAttributes.ETCD_BATCH_ATOMIC: atomic,
     }
-    
+
     attrs.update(kwargs)
     return attrs
 
 
-def build_endpoint_attributes(
-    endpoint: str,
-    **kwargs
-) -> Dict[str, Any]:
+def build_endpoint_attributes(endpoint: str, **kwargs) -> Dict[str, Any]:
     """Build trace attributes for endpoint-related operations.
-    
+
     Args:
         endpoint: The etcd endpoint
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
     attrs = {
         TraceAttributes.ETCD_ENDPOINT: endpoint,
     }
-    
+
     attrs.update(kwargs)
     return attrs
 
 
 def build_error_attributes(
-    error_code: Optional[str] = None,
-    error_message: Optional[str] = None,
-    **kwargs
+    error_code: Optional[str] = None, error_message: Optional[str] = None, **kwargs
 ) -> Dict[str, Any]:
     """Build trace attributes for error cases.
-    
+
     Args:
         error_code: Error code
         error_message: Error message
         **kwargs: Additional attributes
-        
+
     Returns:
         Dictionary of trace attributes
     """
     attrs = {}
-    
+
     if error_code is not None:
         attrs[TraceAttributes.ETCD_ERROR_CODE] = error_code
-    
+
     if error_message is not None:
         # Truncate long error messages
         if len(error_message) > 256:
             error_message = error_message[:256] + "..."
         attrs[TraceAttributes.ETCD_ERROR_MESSAGE] = error_message
-    
+
     attrs.update(kwargs)
     return attrs

etcd3/utils.py

@@ -13,9 +13,9 @@ import grpc
 #     events, cancel = await etcd.watch('/key', filters=[FILTER_DELETE])
 #     # Only PUT events will be received, DELETE events are filtered out
 #
-FILTER_PUT = 0      # Filter out PUT events (only DELETE events will be received)
-FILTER_DELETE = 1   # Filter out DELETE events (only PUT events will be received)
-FILTER_COMMIT = 2   # Filter out all events (no events will be received)
+FILTER_PUT = 0  # Filter out PUT events (only DELETE events will be received)
+FILTER_DELETE = 1  # Filter out DELETE events (only PUT events will be received)
+FILTER_COMMIT = 2  # Filter out all events (no events will be received)
 
 
 class LoadBalancerStrategy(Enum):
@@ -27,6 +27,7 @@ class LoadBalancerStrategy(Enum):
         RANDOM: Random - select random healthy endpoint
         STICKY: Sticky - maintain connection to the same endpoint
     """
+
     PRIORITY = "priority"
     ROUND_ROBIN = "round_robin"
     RANDOM = "random"

etcdrpc/__init__.py

@@ -2,6 +2,7 @@
 
 # 简单的检查，如果文件不存在则报错提示（防御性编程）
 from pathlib import Path
+
 _current_dir = Path(__file__).parent
 if not (_current_dir / "rpc_pb2.py").exists():
     raise ImportError(
@@ -13,4 +14,4 @@ from etcdrpc.rpc_pb2 import *
 from etcdrpc.rpc_pb2_grpc import *
 
 # 获取所有非私有成员
-__all__ = [name for name in globals().keys() if not name.startswith('_')]
+__all__ = [name for name in globals().keys() if not name.startswith("_")]

{python_etcd3_async-0.1.0.dist-info → python_etcd3_async-0.1.2.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: python-etcd3-async
-Version: 0.1.0
+Version: 0.1.2
 Summary: etcd3 async sdk
 Requires-Python: <4,>=3.12
-Requires-Dist: grpcio==1.76.0
+Requires-Dist: grpcio==1.66.2
 Requires-Dist: prometheus-client>=0.24.1
-Requires-Dist: protobuf==6.31.1
 Description-Content-Type: text/markdown
 
 # python-etcd3-async
@@ -25,6 +24,7 @@ Python async client for the etcd API v3, supporting both synchronous and asynchr
 - **Keepalive error propagation**: Lease keepalive errors are properly propagated for connection loss detection
 - **Endpoint failover**: Built-in support for multiple endpoints with automatic failover
 - **Context manager**: Clean resource management for both sync and async
+- **Observability**: Structured logging, OpenTelemetry tracing, and Prometheus metrics
 
 ## Quick Start
 
@@ -294,14 +294,53 @@ client = await async_client(
 )
 ```
 
-## Environment Variables
+## Observability
 
-| Variable | Description |
-|----------|-------------|
-| `ETCD3_LOG_LEVEL` | Set logging level (DEBUG, INFO, WARNING, ERROR) |
+### Configure via Environment
+
+```bash
+export ETCD_OBS_LOG_LEVEL=DEBUG
+export ETCD_OBS_LOG_FORMAT=json
+export ETCD_OBS_TRACING_ENABLED=true
+export ETCD_OBS_PROMETHEUS_ENABLED=true
+```
+
+### Configure Programmatically
+
+```python
+from etcd3 import ObservabilityConfig
+
+config = ObservabilityConfig(
+    tracing_enabled=True,
+    log_format="json",
+    log_level="INFO",
+    prometheus_enabled=True,
+)
+config.apply()
+```
+
+### Access Metrics
+
+```python
+from etcd3.exporters.prometheus import get_exporter
+
+exporter = get_exporter()
+if exporter:
+    print(exporter.metrics().decode())
+```
 
 ## API Reference
 
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `ETCD_OBS_LOG_LEVEL` | INFO | Logging level (DEBUG, INFO, WARNING, ERROR) |
+| `ETCD_OBS_LOG_FORMAT` | text | Log format (text, json, colored) |
+| `ETCD_OBS_TRACING_ENABLED` | true | Enable OpenTelemetry tracing |
+| `ETCD_OBS_TRACING_SERVICE_NAME` | etcd3-client | Service name for tracing |
+| `ETCD_OBS_PROMETHEUS_ENABLED` | false | Enable Prometheus metrics export |
+
 ### Client Factory
 
 | Function | Description |

{python_etcd3_async-0.1.0.dist-info → python_etcd3_async-0.1.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 etcd3/__init__.py,sha256=_G81-O1yZsDNpMp_VvWDS8YNE9EgHEmgAhXdZ5VokP8,2811
 etcd3/async_client.py,sha256=wnzRgPzmFN2Xe0TPxSL-bHTo_lnL01l_I2L6arMGUaw,54229
-etcd3/async_client_extensions.py,sha256=IgW_2l0_h0AtFUFe6uPHYD-7UlBRMdMrwoWEsfDgI0U,34213
+etcd3/async_client_extensions.py,sha256=VWXLhmjBNL1UNhMynZmx5P2sPn_mgTpVXvvU98GDY90,34483
 etcd3/async_endpoint.py,sha256=nDQtXCze1H8SAHIFJ0HYc1dBY2Nc0gw_t3SVT5d1Zmg,4587
 etcd3/async_managers.py,sha256=bUbrqkeq1Rv_qhDGOkIqgSoqA-Lyo10Vbxc60KahtXc,17620
 etcd3/async_monitor.py,sha256=iZPac3Pqn5bI0ONguJJctQsi4b2ft4hWPknug6jj5RY,453
@@ -8,9 +8,9 @@ etcd3/async_watch.py,sha256=m6I2BAoI54J-ZPVVMxao6XJQXvVyQ88Hp2QeauD9z20,15962
 etcd3/client.py,sha256=43OjwOGlxgA3pKTkMZoL4Aem0_Axk7TDrb6-TB6veos,72347
 etcd3/endpoint.py,sha256=aSMBmEitAADW0ABAZhc8L7jPYsQo8amEWKv6LJbsmC4,2589
 etcd3/events.py,sha256=e4gTiUE4SRon8R-if9SKORIM_jr8XtVye-GcV-owKdw,972
-etcd3/exceptions.py,sha256=mCsOaL6Pw1C72JZ8XqvTPiFsklk5CSjyDmMtdqv5Wv4,996
+etcd3/exceptions.py,sha256=W73_Brq7p25clQLW4sC0zKx_EZG7x2JToInwZ9D-gAc,998
 etcd3/leases.py,sha256=7eVl0rA2IGIOBTHbBn0Te9SQ-TKBr4v20X7iUzWYcSo,2804
-etcd3/locks.py,sha256=KBtMS33FLGS13lcvJkIQPelnRLyTUXhqhJRs4De-uts,22533
+etcd3/locks.py,sha256=NrLqqrloZ1HksmQRYb_NEa96Nn-tASS0EgzoTPwG6Oo,22640
 etcd3/log.py,sha256=sMo6av48x9Nf_YDIWdSv8R-VUeVXi1n17wGDAAaFnlM,4282
 etcd3/log_formatters.py,sha256=weWgMQjuI_cZFBEUORGCgkFJQIPvDUaiCLJN64t7s9o,7304
 etcd3/log_sampling.py,sha256=7PhNz-HOZ6sHdBiXS29YJ3baHY_L1VwJaq4NZt2yX78,6692
@@ -18,13 +18,13 @@ etcd3/members.py,sha256=LLg6sAWDaaW0wzl_yBF3ialMQuaRKLFpFDEcmWcbqzY,1414
 etcd3/observability.py,sha256=BLOUMs1H2icF-tEWB_RoZFKoCNoXZt1ZZERGfckesW4,14215
 etcd3/shared.py,sha256=6-mhHNvGD6TPwq79EQa6oGxoZoGKR5oZSZkJeSbZpc8,16195
 etcd3/trace.py,sha256=OtOmAZ5uz7v7dqPoAaEM8d94prK5f5tSEJq7Qi2w_0c,6650
-etcd3/trace_attributes.py,sha256=oE_r3OMvbqm_BWlwKsTWjJucJEQ4osWu0HvwlyI9uc4,12025
+etcd3/trace_attributes.py,sha256=-wk0ZFqjzQT4g7_HErWhJMsVk8ocfPcMDNLJzwDMEjc,11621
 etcd3/transactions.py,sha256=FJe-J5QBm-pV_J9dGIMor35PHAXvb61bjSELkg5Bw4U,7587
-etcd3/utils.py,sha256=M1Rl9LwEvDUlkFBcaK6YPYLAPXjGmgt11d4WWqaNJHc,4811
+etcd3/utils.py,sha256=j10jFnxzZKy5-ImvrWVs18QPbQMvsFmnibPe0Mctm9g,4806
 etcd3/watch.py,sha256=rPEvOm1nQOPzj00OV6GFObZ2uSQqNl2pEcT7ut7xO44,8838
 etcd3/exporters/__init__.py,sha256=9nMfrCsQ-pN5WUIY2ZHBsY4N3xmdD2Z24mDCi19hJE8,362
 etcd3/exporters/prometheus.py,sha256=goA42MAwuR-FI4QH5K4jMOJt51tfC2V9BTeAf9dL5hg,10211
-etcdrpc/__init__.py,sha256=msPVuBwxhRwvr3kn1r6RkUMalHpbXRfrg6A3bNmVu8s,547
+etcdrpc/__init__.py,sha256=-ykqbdDaroJTTyUip4RaZDewcnPPJcOwI9bXYxxXF6Q,549
 etcdrpc/auth.proto,sha256=Py2ysZTy4i89vxRHBdXK-KcPCkojcEfWXDNbDajLRWk,1170
 etcdrpc/auth_pb2.py,sha256=H-HBNZ64Mi0aqMIgjqvgdDcm5DBl9GIhqipRBCt1LlA,2120
 etcdrpc/auth_pb2.pyi,sha256=vEV6IzZnKObqDI6fJPtXAqRbnKZC3vXy4UAem_XZVvY,1985
@@ -37,6 +37,6 @@ etcdrpc/rpc.proto,sha256=UD4vXbdPUNHSLSx7K_UltWqJjWswHBKSs0t9aNMA4qg,31351
 etcdrpc/rpc_pb2.py,sha256=8qhnULNr8jym0qyivDVqJB86H_u1Rb_K8iY8FNT9e0s,30252
 etcdrpc/rpc_pb2.pyi,sha256=TfPtHXIluO_D1rchVMVfoSgZTPQLk-YNhmcJBIt9XIk,35473
 etcdrpc/rpc_pb2_grpc.py,sha256=HOifyKL0X3BmLkS1r0tWTMfyfChBiy76O6Ys12kT5n8,73810
-python_etcd3_async-0.1.0.dist-info/METADATA,sha256=OSgYlmcjLRkK0MJYJrKBb84luLROrXAPYeYe7H-N854,7724
-python_etcd3_async-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-python_etcd3_async-0.1.0.dist-info/RECORD,,
+python_etcd3_async-0.1.2.dist-info/METADATA,sha256=JHiGpX_FT-5svHnzKLIfiev9t9hxWqVZug3Gz_YerF4,8700
+python_etcd3_async-0.1.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+python_etcd3_async-0.1.2.dist-info/RECORD,,

{python_etcd3_async-0.1.0.dist-info → python_etcd3_async-0.1.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: hatchling 1.29.0
 Root-Is-Purelib: true
 Tag: py3-none-any