airbyte-agent-stripe 0.5.25__py3-none-any.whl

airbyte_agent_stripe/_vendored/connector_sdk/logging/logger.py

@@ -0,0 +1,264 @@
+"""Request/response logging implementation."""
+
+import base64
+import json
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Dict, Optional, Set
+
+from .types import LogSession, RequestLog
+
+# Headers to redact for security
+SENSITIVE_HEADERS: Set[str] = {
+    "authorization",
+    "bearer",
+    "api-key",
+    "x-api-key",
+    "token",
+    "secret",
+    "password",
+    "credential",
+}
+
+
+class RequestLogger:
+    """Captures HTTP request/response interactions to a JSON file.
+
+    Implements bounded logging with automatic rotation and flush-before-discard
+    to prevent unbounded memory growth in long-running processes.
+    """
+
+    def __init__(
+        self,
+        log_file: Optional[str] = None,
+        connector_name: Optional[str] = None,
+        max_logs: Optional[int] = 10000,
+    ):
+        """
+        Initialize the request logger.
+
+        Args:
+            log_file: Path to write logs. If None, generates timestamped filename.
+            connector_name: Name of the connector being logged.
+            max_logs: Maximum number of logs to keep in memory before rotation.
+                Set to None for unlimited (not recommended for production).
+                Defaults to 10000.
+        """
+        if log_file is None:
+            timestamp = time.strftime("%Y%m%d_%H%M%S")
+            log_file = f".logs/session_{timestamp}.json"
+
+        self.log_file = Path(log_file)
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        self.session = LogSession(
+            session_id=str(uuid.uuid4()),
+            connector_name=connector_name,
+            max_logs=max_logs,
+        )
+        self._active_requests: Dict[str, Dict[str, Any]] = {}
+        # Store rotated logs that have been flushed from active buffer
+        self._rotated_logs: list[RequestLog] = []
+
+    def _redact_headers(self, headers: Dict[str, str]) -> Dict[str, str]:
+        """Redact sensitive headers."""
+        redacted = {}
+        for key, value in headers.items():
+            if any(sensitive in key.lower() for sensitive in SENSITIVE_HEADERS):
+                redacted[key] = "[REDACTED]"
+            else:
+                redacted[key] = value
+        return redacted
+
+    def _rotate_logs_if_needed(self) -> None:
+        """Rotate logs if max_logs limit is reached.
+
+        Moves oldest logs to _rotated_logs before removing them from active buffer.
+        This ensures logs are preserved for final save() without memory growth.
+        """
+        max_logs = self.session.max_logs
+        if max_logs is None:
+            # Unlimited logging, no rotation needed
+            return
+
+        current_count = len(self.session.logs)
+        if current_count >= max_logs:
+            # Calculate how many logs to rotate (keep buffer at ~90% to avoid thrashing)
+            num_to_rotate = max(1, current_count - int(max_logs * 0.9))
+
+            # Move oldest logs to rotated buffer
+            rotated = self.session.logs[:num_to_rotate]
+            self._rotated_logs.extend(rotated)
+
+            # Remove rotated logs from active buffer
+            self.session.logs = self.session.logs[num_to_rotate:]
+
+    def log_request(
+        self,
+        method: str,
+        url: str,
+        path: str,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[Any] = None,
+    ) -> str:
+        """
+        Log the start of an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            url: Full URL
+            path: Request path
+            headers: Request headers
+            params: Query parameters
+            body: Request body
+
+        Returns:
+            Request ID for correlating with response
+        """
+        request_id = str(uuid.uuid4())
+        self._active_requests[request_id] = {
+            "start_time": time.time(),
+            "method": method,
+            "url": url,
+            "path": path,
+            "headers": self._redact_headers(headers or {}),
+            "params": params,
+            "body": body,
+        }
+        return request_id
+
+    def log_response(
+        self,
+        request_id: str,
+        status_code: int,
+        response_body: Optional[Any] = None,
+    ) -> None:
+        """
+        Log a successful HTTP response.
+
+        Args:
+            request_id: ID returned from log_request
+            status_code: HTTP status code
+            response_body: Response body
+        """
+        if request_id not in self._active_requests:
+            return
+
+        request_data = self._active_requests.pop(request_id)
+        timing_ms = (time.time() - request_data["start_time"]) * 1000
+
+        # Convert bytes to base64 for JSON serialization
+        serializable_body = response_body
+        if isinstance(response_body, bytes):
+            serializable_body = {
+                "_binary": True,
+                "_base64": base64.b64encode(response_body).decode("utf-8"),
+            }
+
+        log_entry = RequestLog(
+            method=request_data["method"],
+            url=request_data["url"],
+            path=request_data["path"],
+            headers=request_data["headers"],
+            params=request_data["params"],
+            body=request_data["body"],
+            response_status=status_code,
+            response_body=serializable_body,
+            timing_ms=timing_ms,
+        )
+
+        self.session.logs.append(log_entry)
+        self._rotate_logs_if_needed()
+
+    def log_error(
+        self,
+        request_id: str,
+        error: str,
+        status_code: Optional[int] = None,
+    ) -> None:
+        """
+        Log an HTTP request error.
+
+        Args:
+            request_id: ID returned from log_request
+            error: Error message
+            status_code: HTTP status code if available
+        """
+        if request_id not in self._active_requests:
+            return
+
+        request_data = self._active_requests.pop(request_id)
+        timing_ms = (time.time() - request_data["start_time"]) * 1000
+
+        log_entry = RequestLog(
+            method=request_data["method"],
+            url=request_data["url"],
+            path=request_data["path"],
+            headers=request_data["headers"],
+            params=request_data["params"],
+            body=request_data["body"],
+            response_status=status_code,
+            timing_ms=timing_ms,
+            error=error,
+        )
+
+        self.session.logs.append(log_entry)
+        self._rotate_logs_if_needed()
+
+    def log_chunk_fetch(self, chunk: bytes) -> None:
+        """Log a chunk from streaming response.
+
+        Args:
+            chunk: Binary chunk data from streaming response
+        """
+        self.session.chunk_logs.append(chunk)
+
+    def save(self) -> None:
+        """Write the current session to the log file.
+
+        Includes both rotated logs and current active logs to ensure
+        no data loss during bounded logging.
+        """
+        # Combine rotated logs with current logs for complete session
+        all_logs = self._rotated_logs + self.session.logs
+
+        # Create a temporary session with all logs for serialization
+        session_data = self.session.model_dump(mode="json")
+        session_data["logs"] = [log.model_dump(mode="json") for log in all_logs]
+
+        with open(self.log_file, "w") as f:
+            json.dump(session_data, f, indent=2, default=str)
+
+    def close(self) -> None:
+        """Finalize and save the logging session."""
+        self.save()
+
+
+class NullLogger:
+    """No-op logger for when logging is disabled."""
+
+    def log_request(self, *args, **kwargs) -> str:
+        """No-op log_request."""
+        return ""
+
+    def log_response(self, *args, **kwargs) -> None:
+        """No-op log_response."""
+        pass
+
+    def log_error(self, *args, **kwargs) -> None:
+        """No-op log_error."""
+        pass
+
+    def log_chunk_fetch(self, chunk: bytes) -> None:
+        """No-op chunk logging for production."""
+        pass
+
+    def save(self) -> None:
+        """No-op save."""
+        pass
+
+    def close(self) -> None:
+        """No-op close."""
+        pass

airbyte_agent_stripe/_vendored/connector_sdk/logging/types.py

@@ -0,0 +1,92 @@
+"""Type definitions for request/response logging."""
+
+import base64
+from datetime import UTC, datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_serializer, field_validator
+
+
+def _utc_now() -> datetime:
+    """Get current UTC datetime (timezone-aware)."""
+    return datetime.now(UTC)
+
+
+def _encode_bytes(v: bytes) -> dict:
+    """Encode bytes as base64 for JSON serialization."""
+    return {"_binary": True, "_base64": base64.b64encode(v).decode("utf-8")}
+
+
+class RequestLog(BaseModel):
+    """Captures a single HTTP request/response interaction."""
+
+    model_config = ConfigDict()
+
+    timestamp: datetime = Field(default_factory=_utc_now)
+    method: str
+    url: str
+    path: str
+    headers: Dict[str, str] = Field(default_factory=dict)
+    params: Optional[Dict[str, Any]] = None
+    body: Optional[Any] = None
+    response_status: Optional[int] = None
+    response_body: Optional[Any] = None
+    timing_ms: Optional[float] = None
+    error: Optional[str] = None
+
+    @field_serializer("timestamp")
+    def serialize_datetime(self, value: datetime) -> str:
+        return value.isoformat()
+
+
+class LogSession(BaseModel):
+    """Collection of request logs with session metadata.
+
+    When max_logs is set, the session will maintain a bounded buffer of recent logs.
+    Older logs should be flushed to disk before being discarded (handled by RequestLogger).
+    """
+
+    model_config = ConfigDict()
+
+    session_id: str
+    started_at: datetime = Field(default_factory=_utc_now)
+    connector_name: Optional[str] = None
+    logs: List[RequestLog] = Field(default_factory=list)
+    max_logs: Optional[int] = Field(
+        default=10000,
+        description="Maximum number of logs to keep in memory. "
+        "When limit is reached, oldest logs should be flushed before removal. "
+        "Set to None for unlimited (not recommended for production).",
+    )
+    chunk_logs: List[bytes] = Field(
+        default_factory=list,
+        description="Captured chunks from streaming responses. " "Each chunk is logged when log_chunk_fetch() is called.",
+    )
+
+    @field_validator("chunk_logs", mode="before")
+    @classmethod
+    def decode_chunk_logs(cls, v: Any) -> List[bytes]:
+        """Decode chunk_logs from JSON representation back to bytes."""
+        if v is None or v == []:
+            return []
+        if isinstance(v, list):
+            result = []
+            for item in v:
+                if isinstance(item, bytes):
+                    result.append(item)
+                elif isinstance(item, dict) and item.get("_binary"):
+                    # Decode from {"_binary": True, "_base64": "..."} format
+                    result.append(base64.b64decode(item["_base64"]))
+                else:
+                    result.append(item)
+            return result
+        return v
+
+    @field_serializer("started_at")
+    def serialize_datetime(self, value: datetime) -> str:
+        return value.isoformat()
+
+    @field_serializer("chunk_logs")
+    def serialize_chunk_logs(self, value: List[bytes]) -> List[dict]:
+        """Serialize bytes chunks as base64 for JSON."""
+        return [_encode_bytes(chunk) for chunk in value]

airbyte_agent_stripe/_vendored/connector_sdk/observability/__init__.py

@@ -0,0 +1,11 @@
+"""Shared observability components for logging and telemetry."""
+
+from .models import OperationMetadata
+from .redactor import DataRedactor
+from .session import ObservabilitySession
+
+__all__ = [
+    "DataRedactor",
+    "ObservabilitySession",
+    "OperationMetadata",
+]

airbyte_agent_stripe/_vendored/connector_sdk/observability/models.py

@@ -0,0 +1,19 @@
+"""Shared operation metadata models."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class OperationMetadata:
+    """Shared operation metadata."""
+
+    entity: str
+    action: str
+    timestamp: datetime
+    timing_ms: Optional[float] = None
+    status_code: Optional[int] = None
+    error_type: Optional[str] = None
+    error_message: Optional[str] = None
+    params: Optional[Dict[str, Any]] = None

airbyte_agent_stripe/_vendored/connector_sdk/observability/redactor.py

@@ -0,0 +1,81 @@
+"""Shared redaction logic for both logging and telemetry."""
+
+from typing import Any, Dict
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+
+
+class DataRedactor:
+    """Shared redaction logic for both logging and telemetry."""
+
+    SENSITIVE_HEADER_PATTERNS = [
+        "authorization",
+        "api-key",
+        "x-api-key",
+        "token",
+        "bearer",
+        "secret",
+        "password",
+        "credential",
+    ]
+
+    SENSITIVE_PARAM_PATTERNS = [
+        "password",
+        "secret",
+        "api_key",
+        "apikey",
+        "token",
+        "credentials",
+        "auth",
+        "key",
+    ]
+
+    @staticmethod
+    def redact_headers(headers: Dict[str, str]) -> Dict[str, str]:
+        """Redact sensitive headers."""
+        redacted = {}
+        for key, value in headers.items():
+            if any(pattern in key.lower() for pattern in DataRedactor.SENSITIVE_HEADER_PATTERNS):
+                redacted[key] = "***REDACTED***"
+            else:
+                redacted[key] = value
+        return redacted
+
+    @staticmethod
+    def redact_params(params: Dict[str, Any]) -> Dict[str, Any]:
+        """Redact sensitive parameters."""
+        redacted = {}
+        for key, value in params.items():
+            if any(pattern in key.lower() for pattern in DataRedactor.SENSITIVE_PARAM_PATTERNS):
+                redacted[key] = "***REDACTED***"
+            else:
+                redacted[key] = value
+        return redacted
+
+    @staticmethod
+    def redact_url(url: str) -> str:
+        """Redact sensitive query params from URL."""
+        parsed = urlparse(url)
+        if not parsed.query:
+            return url
+
+        params = parse_qs(parsed.query)
+        redacted_params = {}
+
+        for key, values in params.items():
+            if any(pattern in key.lower() for pattern in DataRedactor.SENSITIVE_PARAM_PATTERNS):
+                redacted_params[key] = ["***REDACTED***"] * len(values)
+            else:
+                redacted_params[key] = values
+
+        # Reconstruct URL with redacted params
+        new_query = urlencode(redacted_params, doseq=True)
+        return urlunparse(
+            (
+                parsed.scheme,
+                parsed.netloc,
+                parsed.path,
+                parsed.params,
+                new_query,
+                parsed.fragment,
+            )
+        )

airbyte_agent_stripe/_vendored/connector_sdk/observability/session.py

@@ -0,0 +1,94 @@
+"""Shared session context for both logging and telemetry."""
+
+import logging
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def get_persistent_user_id() -> str:
+    """
+    Get or create an anonymous user ID stored in the home directory.
+
+    The ID is stored in ~/.airbyte/ai_sdk_user_id and persists across all sessions.
+    If the file doesn't exist, a new UUID is generated and saved.
+
+    Returns:
+        An anonymous UUID string that uniquely identifies this user across sessions.
+    """
+    try:
+        # Create .airbyte directory in home folder if it doesn't exist
+        airbyte_dir = Path.home() / ".airbyte"
+        airbyte_dir.mkdir(exist_ok=True)
+
+        # Path to user ID file
+        user_id_file = airbyte_dir / "ai_sdk_user_id"
+
+        # Try to read existing user ID
+        if user_id_file.exists():
+            user_id = user_id_file.read_text().strip()
+            if user_id:  # Validate it's not empty
+                return user_id
+
+        # Generate new user ID if file doesn't exist or is empty
+        user_id = str(uuid.uuid4())
+        user_id_file.write_text(user_id)
+        logger.debug(f"Generated new anonymous user ID: {user_id}")
+
+        return user_id
+    except Exception as e:
+        # If we can't read/write the file, generate a session-only ID
+        logger.debug(f"Could not access anonymous user ID file: {e}")
+        return str(uuid.uuid4())
+
+
+def get_public_ip() -> Optional[str]:
+    """
+    Fetch the public IP address of the user.
+
+    Returns None if unable to fetch (network issues, etc).
+    Uses httpx for a robust HTTP request to a public IP service.
+    """
+    try:
+        import httpx
+
+        # Use a short timeout to avoid blocking
+        with httpx.Client(timeout=2.0) as client:
+            response = client.get("https://api.ipify.org?format=text")
+            response.raise_for_status()
+            return response.text.strip()
+    except Exception:
+        # Never fail - just return None
+        return None
+
+
+class ObservabilitySession:
+    """Shared session context for both logging and telemetry."""
+
+    def __init__(
+        self,
+        connector_name: str,
+        connector_version: Optional[str] = None,
+        execution_context: str = "direct",
+        session_id: Optional[str] = None,
+    ):
+        self.session_id = session_id or str(uuid.uuid4())
+        self.user_id = get_persistent_user_id()
+        self.connector_name = connector_name
+        self.connector_version = connector_version
+        self.execution_context = execution_context
+        self.started_at = datetime.now(UTC)
+        self.operation_count = 0
+        self.metadata: Dict[str, Any] = {}
+        self.public_ip = get_public_ip()
+
+    def increment_operations(self):
+        """Increment the operation counter."""
+        self.operation_count += 1
+
+    def duration_seconds(self) -> float:
+        """Calculate session duration in seconds."""
+        return (datetime.now(UTC) - self.started_at).total_seconds()

airbyte_agent_stripe/_vendored/connector_sdk/performance/__init__.py

@@ -0,0 +1,6 @@
+"""Performance monitoring and instrumentation for async operations."""
+
+from .instrumentation import instrument
+from .metrics import PerformanceMonitor
+
+__all__ = ["instrument", "PerformanceMonitor"]

airbyte_agent_stripe/_vendored/connector_sdk/performance/instrumentation.py

@@ -0,0 +1,57 @@
+"""Performance instrumentation decorator for async functions."""
+
+import functools
+import logging
+import time
+from typing import Any, Callable, TypeVar
+
+# Type variable for generic function decoration
+F = TypeVar("F", bound=Callable[..., Any])
+
+logger = logging.getLogger(__name__)
+
+
+def instrument(metric_name: str) -> Callable[[F], F]:
+    """Decorator to instrument async functions with performance tracking.
+
+    Args:
+        metric_name: Name of the metric to track
+
+    Returns:
+        Decorator function
+
+    Example:
+        @instrument("stripe.customer.list")
+        async def list_customers():
+            ...
+    """
+
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            start_time = time.time()
+            success = True
+            error = None
+
+            try:
+                result = await func(*args, **kwargs)
+                return result
+
+            except Exception as e:
+                success = False
+                error = e
+                raise
+
+            finally:
+                duration = time.time() - start_time
+                duration_ms = duration * 1000
+
+                # Log performance metrics
+                if success:
+                    logger.debug(f"[{metric_name}] completed in {duration_ms:.2f}ms")
+                else:
+                    logger.warning(f"[{metric_name}] failed after {duration_ms:.2f}ms: {error}")
+
+        return wrapper  # type: ignore
+
+    return decorator