airbyte-agent-greenhouse 0.17.48__py3-none-any.whl

airbyte_agent_greenhouse/_vendored/connector_sdk/observability/config.py

@@ -0,0 +1,179 @@
+"""Unified configuration for connector-sdk."""
+
+import logging
+import os
+import tempfile
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+# New config location
+CONFIG_DIR = Path.home() / ".airbyte" / "connector-sdk"
+CONFIG_PATH = CONFIG_DIR / "config.yaml"
+
+# Legacy file locations (for migration)
+LEGACY_USER_ID_PATH = Path.home() / ".airbyte" / "ai_sdk_user_id"
+LEGACY_INTERNAL_MARKER_PATH = Path.home() / ".airbyte" / "internal_user"
+
+
+@dataclass
+class SDKConfig:
+    """Connector SDK configuration."""
+
+    user_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    is_internal_user: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for YAML serialization."""
+        return {
+            "user_id": self.user_id,
+            "is_internal_user": self.is_internal_user,
+        }
+
+
+def _delete_legacy_files() -> None:
+    """
+    Delete legacy config files after successful migration.
+
+    Removes:
+    - ~/.airbyte/ai_sdk_user_id
+    - ~/.airbyte/internal_user
+    """
+    for legacy_path in [LEGACY_USER_ID_PATH, LEGACY_INTERNAL_MARKER_PATH]:
+        try:
+            if legacy_path.exists():
+                legacy_path.unlink()
+                logger.debug(f"Deleted legacy config file: {legacy_path}")
+        except Exception as e:
+            logger.debug(f"Could not delete legacy file {legacy_path}: {e}")
+
+
+def _migrate_legacy_config() -> SDKConfig | None:
+    """
+    Migrate from legacy file-based config to new YAML format.
+
+    Reads from:
+    - ~/.airbyte/ai_sdk_user_id (user_id)
+    - ~/.airbyte/internal_user (is_internal_user marker)
+
+    Returns SDKConfig if migration was successful, None otherwise.
+    """
+    user_id = None
+    is_internal = False
+
+    # Try to read legacy user_id
+    try:
+        if LEGACY_USER_ID_PATH.exists():
+            user_id = LEGACY_USER_ID_PATH.read_text().strip()
+            if not user_id:
+                user_id = None
+    except Exception:
+        pass
+
+    # Check legacy internal_user marker
+    try:
+        is_internal = LEGACY_INTERNAL_MARKER_PATH.exists()
+    except Exception:
+        pass
+
+    if user_id or is_internal:
+        return SDKConfig(
+            user_id=user_id or str(uuid.uuid4()),
+            is_internal_user=is_internal,
+        )
+
+    return None
+
+
+def load_config() -> SDKConfig:
+    """
+    Load SDK configuration from config file.
+
+    Checks (in order):
+    1. New config file at ~/.airbyte/connector-sdk/config.yaml
+    2. Legacy files at ~/.airbyte/ai_sdk_user_id and ~/.airbyte/internal_user
+    3. Creates new config with generated user_id if nothing exists
+
+    Environment variable AIRBYTE_INTERNAL_USER can override is_internal_user.
+
+    Returns:
+        SDKConfig with user_id and is_internal_user
+    """
+    config = None
+
+    # Try to load from new config file
+    try:
+        if CONFIG_PATH.exists():
+            content = CONFIG_PATH.read_text()
+            data = yaml.safe_load(content) or {}
+            config = SDKConfig(
+                user_id=data.get("user_id", str(uuid.uuid4())),
+                is_internal_user=data.get("is_internal_user", False),
+            )
+            # Always clean up legacy files if they exist (even if new config exists)
+            _delete_legacy_files()
+    except Exception as e:
+        logger.debug(f"Could not load config from {CONFIG_PATH}: {e}")
+
+    # Try to migrate from legacy files if new config doesn't exist
+    if config is None:
+        config = _migrate_legacy_config()
+        if config:
+            # Save migrated config to new location
+            try:
+                save_config(config)
+                logger.debug("Migrated legacy config to new location")
+                # Delete legacy files after successful migration
+                _delete_legacy_files()
+            except Exception as e:
+                logger.debug(f"Could not save migrated config: {e}")
+
+    # Create new config if nothing exists
+    if config is None:
+        config = SDKConfig()
+        try:
+            save_config(config)
+        except Exception as e:
+            logger.debug(f"Could not save new config: {e}")
+
+    # Environment variable override for is_internal_user
+    env_value = os.getenv("AIRBYTE_INTERNAL_USER", "").lower()
+    if env_value in ("true", "1", "yes"):
+        config.is_internal_user = True
+    elif env_value:
+        # Any other non-empty value (including "false", "0", "no") defaults to False
+        config.is_internal_user = False
+
+    return config
+
+
+def save_config(config: SDKConfig) -> None:
+    """
+    Save SDK configuration to config file.
+
+    Creates the config directory if it doesn't exist.
+    Uses atomic writes to prevent corruption from concurrent access.
+
+    Args:
+        config: SDKConfig to save
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Use atomic write: write to temp file then rename (atomic on POSIX)
+    fd, temp_path = tempfile.mkstemp(dir=CONFIG_DIR, suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w") as f:
+            yaml.dump(config.to_dict(), f, default_flow_style=False)
+        os.rename(temp_path, CONFIG_PATH)
+    except Exception:
+        # Clean up temp file on failure
+        try:
+            os.unlink(temp_path)
+        except OSError:
+            pass
+        raise

airbyte_agent_greenhouse/_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
+
+
+@dataclass
+class OperationMetadata:
+    """Shared operation metadata."""
+
+    entity: str
+    action: str
+    timestamp: datetime
+    timing_ms: float | None = None
+    status_code: int | None = None
+    error_type: str | None = None
+    error_message: str | None = None
+    params: Dict[str, Any] | None = None

airbyte_agent_greenhouse/_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_greenhouse/_vendored/connector_sdk/observability/session.py

@@ -0,0 +1,103 @@
+"""Shared session context for both logging and telemetry."""
+
+import logging
+import uuid
+from datetime import UTC, datetime
+from typing import Any, Dict
+
+from .config import SDKConfig, load_config
+
+logger = logging.getLogger(__name__)
+
+# Cache the config at module level to avoid repeated reads
+_cached_config: SDKConfig | None = None
+
+
+def _get_config() -> SDKConfig:
+    """Get cached SDK config or load from file."""
+    global _cached_config
+    if _cached_config is None:
+        _cached_config = load_config()
+    return _cached_config
+
+
+def _clear_config_cache() -> None:
+    """Clear the cached config. Used for testing."""
+    global _cached_config
+    _cached_config = None
+
+
+def get_persistent_user_id() -> str:
+    """
+    Get the persistent anonymous user ID.
+
+    Now reads from ~/.airbyte/connector-sdk/config.yaml
+
+    Returns:
+        An anonymous UUID string that uniquely identifies this user across sessions.
+    """
+    return _get_config().user_id
+
+
+def get_public_ip() -> str | None:
+    """
+    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:
+        # NOTE: Import here intentionally - this is a non-critical network call
+        # that may fail. Importing at module level would make httpx a hard dependency.
+        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
+
+
+def get_is_internal_user() -> bool:
+    """
+    Check if the current user is an internal Airbyte user.
+
+    Now reads from ~/.airbyte/connector-sdk/config.yaml
+    Environment variable AIRBYTE_INTERNAL_USER can override.
+
+    Returns False if not set or on any error.
+    """
+    return _get_config().is_internal_user
+
+
+class ObservabilitySession:
+    """Shared session context for both logging and telemetry."""
+
+    def __init__(
+        self,
+        connector_name: str,
+        connector_version: str | None = None,
+        execution_context: str = "direct",
+        session_id: str | None = 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()
+        self.is_internal_user = get_is_internal_user()
+
+    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_greenhouse/_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_greenhouse/_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

airbyte_agent_greenhouse/_vendored/connector_sdk/performance/metrics.py

@@ -0,0 +1,93 @@
+"""Performance metrics tracking."""
+
+import time
+from contextlib import asynccontextmanager
+from typing import Dict
+
+
+class PerformanceMonitor:
+    """Monitor and track performance metrics for operations."""
+
+    def __init__(self):
+        """Initialize performance monitor."""
+        self._metrics: Dict[str, Dict[str, float]] = {}
+
+    def record(self, metric_name: str, duration: float):
+        """Record a metric.
+
+        Args:
+            metric_name: Name of the metric
+            duration: Duration in seconds
+        """
+        if metric_name not in self._metrics:
+            self._metrics[metric_name] = {
+                "count": 0,
+                "total": 0.0,
+                "min": float("inf"),
+                "max": 0.0,
+            }
+
+        metrics = self._metrics[metric_name]
+        metrics["count"] += 1
+        metrics["total"] += duration
+        metrics["min"] = min(metrics["min"], duration)
+        metrics["max"] = max(metrics["max"], duration)
+
+    def get_stats(self, metric_name: str) -> Dict[str, float] | None:
+        """Get statistics for a metric.
+
+        Args:
+            metric_name: Name of the metric
+
+        Returns:
+            Dictionary with count, total, mean, min, max or None if metric not found
+        """
+        if metric_name not in self._metrics:
+            return None
+
+        metrics = self._metrics[metric_name]
+        return {
+            "count": metrics["count"],
+            "total": metrics["total"],
+            "mean": metrics["total"] / metrics["count"] if metrics["count"] > 0 else 0.0,
+            "min": metrics["min"] if metrics["min"] != float("inf") else 0.0,
+            "max": metrics["max"],
+        }
+
+    def get_all_stats(self) -> Dict[str, Dict[str, float]]:
+        """Get statistics for all metrics.
+
+        Returns:
+            Dictionary mapping metric names to their statistics
+        """
+        return {name: self.get_stats(name) for name in self._metrics.keys()}
+
+    def reset(self, metric_name: str | None = None):
+        """Reset metrics.
+
+        Args:
+            metric_name: Specific metric to reset, or None to reset all
+        """
+        if metric_name:
+            if metric_name in self._metrics:
+                del self._metrics[metric_name]
+        else:
+            self._metrics.clear()
+
+    @asynccontextmanager
+    async def track(self, metric_name: str):
+        """Context manager for tracking operation duration.
+
+        Args:
+            metric_name: Name of the metric to track
+
+        Example:
+            async with monitor.track("api_call"):
+                result = await some_async_operation()
+        """
+        start_time = time.time()
+        try:
+            yield
+        finally:
+            duration = time.time() - start_time
+            self.record(metric_name, duration)

airbyte_agent_greenhouse/_vendored/connector_sdk/schema/__init__.py

@@ -0,0 +1,75 @@
+"""
+Pydantic 2 schema models for OpenAPI 3.0 connector specifications.
+
+This package provides strongly-typed Pydantic models that mirror the OpenAPI 3.0
+specification while supporting Airbyte-specific extensions.
+
+Usage:
+    import yaml
+    from . import OpenAPIConnector
+
+    with open('connector.yaml') as f:
+        data = yaml.safe_load(f)
+
+    connector = OpenAPIConnector(**data)
+    print(connector.list_resources())
+"""
+
+from .base import Contact, Info, License, Server, ServerVariable
+from .components import (
+    Components,
+    Header,
+    MediaType,
+    Parameter,
+    RequestBody,
+    Response,
+    Schema,
+)
+from .connector import ExternalDocs, OpenAPIConnector, Tag
+from .extensions import PaginationConfig, RateLimitConfig, RetryConfig
+from .operations import Operation, PathItem
+from .security import (
+    AirbyteAuthConfig,
+    AuthConfigFieldSpec,
+    AuthConfigOption,
+    OAuth2Flow,
+    OAuth2Flows,
+    SecurityRequirement,
+    SecurityScheme,
+)
+
+__all__ = [
+    # Root model
+    "OpenAPIConnector",
+    "Tag",
+    "ExternalDocs",
+    # Base models
+    "Info",
+    "Server",
+    "ServerVariable",
+    "Contact",
+    "License",
+    # Security models
+    "SecurityScheme",
+    "SecurityRequirement",
+    "OAuth2Flow",
+    "OAuth2Flows",
+    "AirbyteAuthConfig",
+    "AuthConfigOption",
+    "AuthConfigFieldSpec",
+    # Component models
+    "Components",
+    "Schema",
+    "Parameter",
+    "RequestBody",
+    "Response",
+    "MediaType",
+    "Header",
+    # Operation models
+    "PathItem",
+    "Operation",
+    # Extension models (for future use)
+    "PaginationConfig",
+    "RateLimitConfig",
+    "RetryConfig",
+]