airbyte-internal-ops 0.1.11__py3-none-any.whl → 0.2.1__py3-none-any.whl

airbyte_ops_mcp/prod_db_access/db_engine.py

@@ -52,6 +52,7 @@ def _is_tailscale_connected() -> bool:
     Detection methods:
     1. Check for tailscale0 network interface (Linux)
     2. Run 'tailscale status --json' and check backend state (cross-platform)
+    3. Check macOS-specific Tailscale.app location if tailscale not in PATH
     """
     # Method 1: Check for tailscale0 interface (Linux)
     try:
@@ -63,6 +64,13 @@ def _is_tailscale_connected() -> bool:
 
     # Method 2: Check tailscale CLI status
     tailscale_path = shutil.which("tailscale")
+
+    # Method 3: On macOS, check the standard Tailscale.app location if not in PATH
+    if not tailscale_path and os.path.exists(
+        "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+    ):
+        tailscale_path = "/Applications/Tailscale.app/Contents/MacOS/Tailscale"
+
     if tailscale_path:
         try:
             result = subprocess.run(
@@ -158,24 +166,20 @@ def _get_connector() -> Connector:
 
 
 def _get_secret_value(
-    gsm_client: secretmanager.SecretManagerServiceClient, secret_id: str
+    gsm_client: secretmanager.SecretManagerServiceClient,
+    secret_id: str,
 ) -> str:
-    """Get the value of the enabled version of a secret.
+    """Get the value of the latest version of a secret.
 
     Args:
         gsm_client: GCP Secret Manager client
-        secret_id: The id of the secret
+        secret_id: The full resource ID of the secret
+            (e.g., "projects/123/secrets/my-secret")
 
     Returns:
-        The value of the enabled version of the secret
+        The value of the latest version of the secret
     """
-    response = gsm_client.list_secret_versions(
-        request={"parent": secret_id, "filter": "state:ENABLED"}
-    )
-    if len(response.versions) == 0:
-        raise ValueError(f"No enabled version of secret {secret_id} found")
-    enabled_version = response.versions[0]
-    response = gsm_client.access_secret_version(name=enabled_version.name)
+    response = gsm_client.access_secret_version(name=f"{secret_id}/versions/latest")
     return response.payload.data.decode("UTF-8")
 
 

airbyte_ops_mcp/prod_db_access/queries.py

@@ -24,7 +24,7 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
-    SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION,
+    SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
     SELECT_NEW_CONNECTOR_RELEASES,
     SELECT_ORG_WORKSPACES,
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
@@ -225,43 +225,55 @@ def query_sync_results_for_version(
     )
 
 
-def query_failed_sync_attempts_for_version(
-    connector_version_id: str,
+def query_failed_sync_attempts_for_connector(
+    connector_definition_id: str,
+    organization_id: str | None = None,
     days: int = 7,
     limit: int = 100,
     *,
     gsm_client: secretmanager.SecretManagerServiceClient | None = None,
 ) -> list[dict[str, Any]]:
-    """Query failed sync job results with attempt details for actors pinned to a version.
+    """Query failed sync attempts for ALL actors using a connector definition.
 
-    This query joins to the attempts table to include failure_summary and other
-    attempt-level details useful for debugging. Date filters are applied to both
-    jobs and attempts tables to optimize join performance.
+    Finds all actors with the given actor_definition_id and returns their failed
+    sync attempts, regardless of whether they have explicit version pins.
 
-    Note: This may return multiple rows per job (one per attempt). Results are
-    ordered by job_updated_at DESC, then attempt_number DESC.
+    This is useful for investigating connector issues across all users.
+
+    Note: This query only supports SOURCE connectors (joins via connection.source_id).
+    For destination connectors, a separate query would be needed.
 
     Args:
-        connector_version_id: Connector version UUID to filter by
+        connector_definition_id: Connector definition UUID to filter by
+        organization_id: Optional organization UUID to filter results by (post-query filter)
         days: Number of days to look back (default: 7)
         limit: Maximum number of results (default: 100)
         gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
 
     Returns:
-        List of failed sync job results with attempt details including failure_summary
+        List of failed sync attempt records with failure_summary and workspace info
     """
     cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
-    return _run_sql_query(
-        SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION,
+
+    results = _run_sql_query(
+        SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
         parameters={
-            "actor_definition_version_id": connector_version_id,
+            "connector_definition_id": connector_definition_id,
             "cutoff_date": cutoff_date,
             "limit": limit,
         },
-        query_name="SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION",
+        query_name="SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR",
         gsm_client=gsm_client,
     )
 
+    # Post-query filter by organization_id if provided
+    if organization_id is not None:
+        results = [
+            r for r in results if str(r.get("organization_id")) == organization_id
+        ]
+
+    return results
+
 
 def query_dataplanes_list(
     *,

airbyte_ops_mcp/prod_db_access/sql.py

@@ -305,32 +305,33 @@ SELECT_SUCCESSFUL_SYNCS_FOR_VERSION = sqlalchemy.text(
     """
 )
 
-# Get failed attempt results for actors pinned to a specific connector definition VERSION ID
-# Includes attempt details (failure_summary, etc.) for research/debugging
-# Filters on attempts.status = 'failed' to capture all failed attempts, including those
-# from jobs that eventually succeeded via retry. The latest_job_attempt_status field
-# indicates whether the job eventually succeeded or remained failed.
-# Query starts from attempts table to leverage indexed columns (ended_at, status)
-# Note: attempts.ended_at and attempts.status are indexed (btree)
-SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION = sqlalchemy.text(
+# Get failed attempt results for ALL actors using a connector definition.
+# Finds all actors with the given actor_definition_id and returns their failed sync attempts,
+# regardless of whether they have explicit version pins.
+# Query starts from attempts table to leverage indexed columns (ended_at, status).
+# Note: This query only supports SOURCE connectors (joins via connection.source_id).
+# The LEFT JOIN to scoped_configuration provides pin context when available (pin_origin_type,
+# pin_origin, pinned_version_id will be NULL for unpinned actors).
+SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR = sqlalchemy.text(
     """
     SELECT
          jobs.id AS job_id,
          jobs.scope AS connection_id,
-         jobs.status AS latest_job_attempt_status,
+         jobs.status AS latest_job_status,
          jobs.started_at AS job_started_at,
          jobs.updated_at AS job_updated_at,
          connection.name AS connection_name,
          actor.id AS actor_id,
          actor.name AS actor_name,
          actor.actor_definition_id,
-         scoped_configuration.origin_type AS pin_origin_type,
-         scoped_configuration.origin AS pin_origin,
          workspace.id AS workspace_id,
          workspace.name AS workspace_name,
          workspace.organization_id,
          workspace.dataplane_group_id,
          dataplane_group.name AS dataplane_name,
+         scoped_configuration.origin_type AS pin_origin_type,
+         scoped_configuration.origin AS pin_origin,
+         scoped_configuration.value AS pinned_version_id,
          attempts.id AS failed_attempt_id,
          attempts.attempt_number AS failed_attempt_number,
          attempts.status AS failed_attempt_status,
@@ -347,15 +348,15 @@ SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION = sqlalchemy.text(
       ON jobs.scope = connection.id::text
     JOIN actor
       ON connection.source_id = actor.id
-    JOIN scoped_configuration
-      ON scoped_configuration.scope_id = actor.id
-     AND scoped_configuration.key = 'connector_version'
-     AND scoped_configuration.scope_type = 'actor'
-     AND scoped_configuration.value = :actor_definition_version_id
+     AND actor.actor_definition_id = :connector_definition_id
     JOIN workspace
       ON actor.workspace_id = workspace.id
     LEFT JOIN dataplane_group
       ON workspace.dataplane_group_id = dataplane_group.id
+    LEFT JOIN scoped_configuration
+      ON scoped_configuration.scope_id = actor.id
+     AND scoped_configuration.key = 'connector_version'
+     AND scoped_configuration.scope_type = 'actor'
     WHERE
          attempts.ended_at >= :cutoff_date
      AND attempts.status = 'failed'

airbyte_ops_mcp/{live_tests → regression_tests}/__init__.py

@@ -5,17 +5,17 @@ This module provides tools for testing Airbyte connectors against live data
 without using Dagger. It uses Docker SDK directly for container orchestration.
 """
 
-from airbyte_ops_mcp.live_tests.connection_fetcher import (
+from airbyte_ops_mcp.regression_tests.connection_fetcher import (
     ConnectionData,
     fetch_connection_data,
 )
-from airbyte_ops_mcp.live_tests.connection_secret_retriever import (
+from airbyte_ops_mcp.regression_tests.connection_secret_retriever import (
     enrich_config_with_secrets,
     is_secret_retriever_enabled,
     retrieve_unmasked_config,
     should_use_secret_retriever,
 )
-from airbyte_ops_mcp.live_tests.models import (
+from airbyte_ops_mcp.regression_tests.models import (
     Command,
     ConnectorUnderTest,
     ExecutionResult,

airbyte_ops_mcp/{live_tests → regression_tests}/cdk_secrets.py

@@ -5,7 +5,7 @@ This module uses the PyAirbyte GoogleGSMSecretManager to retrieve
 integration test secrets from Google Secret Manager for connectors.
 
 Usage:
-    from airbyte_ops_mcp.live_tests.cdk_secrets import get_first_config_from_secrets
+    from airbyte_ops_mcp.regression_tests.cdk_secrets import get_first_config_from_secrets
 
     # Fetch the first config for a connector
     config = get_first_config_from_secrets("source-github")

airbyte_ops_mcp/{live_tests → regression_tests}/connection_secret_retriever.py

@@ -11,8 +11,8 @@ The secret retriever requires:
 - Cloud SQL Proxy running to internal Postgres (or CI environment)
 
 Usage:
-    from airbyte_ops_mcp.live_tests.connection_fetcher import fetch_connection_data
-    from airbyte_ops_mcp.live_tests.connection_secret_retriever import (
+    from airbyte_ops_mcp.regression_tests.connection_fetcher import fetch_connection_data
+    from airbyte_ops_mcp.regression_tests.connection_secret_retriever import (
         enrich_config_with_secrets,
         should_use_secret_retriever,
     )
@@ -42,7 +42,7 @@ from airbyte_ops_mcp.connection_config_retriever import (
 from airbyte_ops_mcp.gcp_auth import ensure_adc_credentials
 
 if TYPE_CHECKING:
-    from airbyte_ops_mcp.live_tests.connection_fetcher import ConnectionData
+    from airbyte_ops_mcp.regression_tests.connection_fetcher import ConnectionData
 
 logger = logging.getLogger(__name__)
 

airbyte_ops_mcp/{live_tests → regression_tests}/connector_runner.py

@@ -15,7 +15,7 @@ import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-from airbyte_ops_mcp.live_tests.models import (
+from airbyte_ops_mcp.regression_tests.models import (
     Command,
     ExecutionInputs,
     ExecutionResult,

airbyte_ops_mcp/{live_tests → regression_tests}/message_cache/__init__.py

@@ -8,7 +8,9 @@ Based on airbyte-ci implementation:
 https://github.com/airbytehq/airbyte/tree/master/airbyte-ci/connectors/live-tests/src/live_tests/commons/backends
 """
 
-from airbyte_ops_mcp.live_tests.message_cache.duckdb_cache import DuckDbMessageCache
+from airbyte_ops_mcp.regression_tests.message_cache.duckdb_cache import (
+    DuckDbMessageCache,
+)
 
 __all__ = [
     "DuckDbMessageCache",

airbyte_ops_mcp/{live_tests → regression_tests}/regression/__init__.py

@@ -8,7 +8,7 @@ Based on airbyte-ci implementation:
 https://github.com/airbytehq/airbyte/blob/master/airbyte-ci/connectors/live-tests/src/live_tests/regression_tests/test_read.py
 """
 
-from airbyte_ops_mcp.live_tests.regression.comparators import (
+from airbyte_ops_mcp.regression_tests.regression.comparators import (
     ComparisonResult,
     RecordDiff,
     StreamComparisonResult,

airbyte_ops_mcp/{live_tests → regression_tests}/schema_generation.py

@@ -19,7 +19,9 @@ from airbyte_protocol.models import AirbyteMessage
 from airbyte_protocol.models import Type as AirbyteMessageType
 from genson import SchemaBuilder
 
-from airbyte_ops_mcp.live_tests.obfuscation import convert_obfuscated_record_to_typed
+from airbyte_ops_mcp.regression_tests.obfuscation import (
+    convert_obfuscated_record_to_typed,
+)
 
 logger = logging.getLogger(__name__)
 

airbyte_ops_mcp/{live_tests → regression_tests}/validation/__init__.py

@@ -8,7 +8,7 @@ Based on airbyte-ci validation tests:
 https://github.com/airbytehq/airbyte/tree/master/airbyte-ci/connectors/live-tests/src/live_tests/validation_tests
 """
 
-from airbyte_ops_mcp.live_tests.validation.catalog_validators import (
+from airbyte_ops_mcp.regression_tests.validation.catalog_validators import (
     ValidationResult,
     validate_additional_properties_is_true,
     validate_catalog,
@@ -20,7 +20,7 @@ from airbyte_ops_mcp.live_tests.validation.catalog_validators import (
     validate_schemas_are_valid_json_schema,
     validate_streams_have_sync_modes,
 )
-from airbyte_ops_mcp.live_tests.validation.record_validators import (
+from airbyte_ops_mcp.regression_tests.validation.record_validators import (
     validate_primary_keys_in_records,
     validate_records_conform_to_schema,
     validate_state_messages_emitted,

airbyte_ops_mcp/{live_tests → regression_tests}/validation/record_validators.py

@@ -15,10 +15,12 @@ import jsonschema
 from airbyte_protocol.models import AirbyteMessage, AirbyteStateType
 from airbyte_protocol.models import Type as AirbyteMessageType
 
-from airbyte_ops_mcp.live_tests.validation.catalog_validators import ValidationResult
+from airbyte_ops_mcp.regression_tests.validation.catalog_validators import (
+    ValidationResult,
+)
 
 if TYPE_CHECKING:
-    from airbyte_ops_mcp.live_tests.models import ExecutionResult
+    from airbyte_ops_mcp.regression_tests.models import ExecutionResult
 
 
 def validate_records_conform_to_schema(