airbyte-internal-ops 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

airbyte_ops_mcp/prod_db_access/queries.py

@@ -26,9 +26,17 @@ from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_CONNECTIONS_BY_DESTINATION_CONNECTOR_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
+    SELECT_DESTINATION_CONNECTION_STATS,
     SELECT_FAILED_SYNC_ATTEMPTS_FOR_CONNECTOR,
     SELECT_NEW_CONNECTOR_RELEASES,
     SELECT_ORG_WORKSPACES,
+    SELECT_RECENT_FAILED_SYNCS_FOR_DESTINATION_CONNECTOR,
+    SELECT_RECENT_FAILED_SYNCS_FOR_SOURCE_CONNECTOR,
+    SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_DESTINATION_CONNECTOR,
+    SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_SOURCE_CONNECTOR,
+    SELECT_RECENT_SYNCS_FOR_DESTINATION_CONNECTOR,
+    SELECT_RECENT_SYNCS_FOR_SOURCE_CONNECTOR,
+    SELECT_SOURCE_CONNECTION_STATS,
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
     SELECT_SYNC_RESULTS_FOR_VERSION,
     SELECT_WORKSPACE_INFO,
@@ -227,7 +235,7 @@ def query_actors_pinned_to_version(
     )
 
 
-def query_sync_results_for_version(
+def query_syncs_for_version_pinned_connector(
     connector_version_id: str,
     days: int = 7,
     limit: int = 100,
@@ -320,6 +328,81 @@ def query_failed_sync_attempts_for_connector(
     return results
 
 
+def query_recent_syncs_for_connector(
+    connector_definition_id: str,
+    is_destination: bool = False,
+    status_filter: str = "all",
+    organization_id: str | None = None,
+    days: int = 7,
+    limit: int = 100,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query recent sync jobs for ALL actors using a connector definition.
+
+    Finds all actors with the given actor_definition_id and returns their sync jobs,
+    regardless of whether they have explicit version pins. Filters out deleted actors,
+    deleted workspaces, and deprecated connections.
+
+    This is useful for finding healthy connections with recent successful syncs,
+    or for investigating connector issues across all users.
+
+    Args:
+        connector_definition_id: Connector definition UUID to filter by
+        is_destination: If True, query destination connectors; if False, query sources
+        status_filter: Filter by job status - "all", "succeeded", or "failed"
+        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 sync job records with workspace info and optional pin context
+    """
+    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+
+    # Select the appropriate query based on connector type and status filter
+    if is_destination:
+        if status_filter == "succeeded":
+            query = SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_DESTINATION_CONNECTOR
+            query_name = "SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_DESTINATION_CONNECTOR"
+        elif status_filter == "failed":
+            query = SELECT_RECENT_FAILED_SYNCS_FOR_DESTINATION_CONNECTOR
+            query_name = "SELECT_RECENT_FAILED_SYNCS_FOR_DESTINATION_CONNECTOR"
+        else:
+            query = SELECT_RECENT_SYNCS_FOR_DESTINATION_CONNECTOR
+            query_name = "SELECT_RECENT_SYNCS_FOR_DESTINATION_CONNECTOR"
+    else:
+        if status_filter == "succeeded":
+            query = SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_SOURCE_CONNECTOR
+            query_name = "SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_SOURCE_CONNECTOR"
+        elif status_filter == "failed":
+            query = SELECT_RECENT_FAILED_SYNCS_FOR_SOURCE_CONNECTOR
+            query_name = "SELECT_RECENT_FAILED_SYNCS_FOR_SOURCE_CONNECTOR"
+        else:
+            query = SELECT_RECENT_SYNCS_FOR_SOURCE_CONNECTOR
+            query_name = "SELECT_RECENT_SYNCS_FOR_SOURCE_CONNECTOR"
+
+    results = _run_sql_query(
+        query,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "cutoff_date": cutoff_date,
+            "limit": limit,
+        },
+        query_name=query_name,
+        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(
     *,
     gsm_client: secretmanager.SecretManagerServiceClient | None = None,
@@ -416,3 +499,69 @@ def query_workspaces_by_email_domain(
         query_name="SELECT_WORKSPACES_BY_EMAIL_DOMAIN",
         gsm_client=gsm_client,
     )
+
+
+def query_source_connection_stats(
+    connector_definition_id: str,
+    days: int = 7,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query aggregate connection stats for a SOURCE connector.
+
+    Returns counts of connections grouped by pinned version, including:
+    - Total, enabled, and active connection counts
+    - Pinned vs unpinned breakdown
+    - Latest attempt status breakdown (succeeded, failed, cancelled, running, unknown)
+
+    Args:
+        connector_definition_id: Source connector definition UUID
+        days: Number of days to look back for "active" connections (default: 7)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of dicts with aggregate counts grouped by pinned_version_id
+    """
+    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+    return _run_sql_query(
+        SELECT_SOURCE_CONNECTION_STATS,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "cutoff_date": cutoff_date,
+        },
+        query_name="SELECT_SOURCE_CONNECTION_STATS",
+        gsm_client=gsm_client,
+    )
+
+
+def query_destination_connection_stats(
+    connector_definition_id: str,
+    days: int = 7,
+    *,
+    gsm_client: secretmanager.SecretManagerServiceClient | None = None,
+) -> list[dict[str, Any]]:
+    """Query aggregate connection stats for a DESTINATION connector.
+
+    Returns counts of connections grouped by pinned version, including:
+    - Total, enabled, and active connection counts
+    - Pinned vs unpinned breakdown
+    - Latest attempt status breakdown (succeeded, failed, cancelled, running, unknown)
+
+    Args:
+        connector_definition_id: Destination connector definition UUID
+        days: Number of days to look back for "active" connections (default: 7)
+        gsm_client: GCP Secret Manager client. If None, a new client will be instantiated.
+
+    Returns:
+        List of dicts with aggregate counts grouped by pinned_version_id
+    """
+    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+    return _run_sql_query(
+        SELECT_DESTINATION_CONNECTION_STATS,
+        parameters={
+            "connector_definition_id": connector_definition_id,
+            "cutoff_date": cutoff_date,
+        },
+        query_name="SELECT_DESTINATION_CONNECTION_STATS",
+        gsm_client=gsm_client,
+    )

airbyte_ops_mcp/prod_db_access/sql.py

@@ -360,6 +360,305 @@ SELECT_SUCCESSFUL_SYNCS_FOR_VERSION = sqlalchemy.text(
     """
 )
 
+# Get recent sync results for ALL actors using a SOURCE connector definition.
+# Finds all actors with the given actor_definition_id and returns their sync attempts,
+# regardless of whether they have explicit version pins.
+# Query starts from jobs table to leverage indexed columns.
+# 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).
+# Status filtering ('all', 'succeeded', 'failed') is handled at the application layer by
+# selecting among different SQL query constants; this query returns all statuses.
+SELECT_RECENT_SYNCS_FOR_SOURCE_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS 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,
+         actor.tombstone AS actor_tombstone,
+         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
+    FROM jobs
+    JOIN connection
+      ON jobs.scope = connection.id::text
+     AND connection.status != 'deprecated'
+    JOIN actor
+      ON connection.source_id = actor.id
+     AND actor.actor_definition_id = :connector_definition_id
+     AND actor.tombstone = false
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    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
+         jobs.config_type = 'sync'
+     AND jobs.updated_at >= :cutoff_date
+    ORDER BY
+         jobs.updated_at DESC
+    LIMIT :limit
+    """
+)
+
+# Same as above but filtered to only successful syncs
+SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_SOURCE_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS 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,
+         actor.tombstone AS actor_tombstone,
+         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
+    FROM jobs
+    JOIN connection
+      ON jobs.scope = connection.id::text
+     AND connection.status != 'deprecated'
+    JOIN actor
+      ON connection.source_id = actor.id
+     AND actor.actor_definition_id = :connector_definition_id
+     AND actor.tombstone = false
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    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
+         jobs.config_type = 'sync'
+     AND jobs.status = 'succeeded'
+     AND jobs.updated_at >= :cutoff_date
+    ORDER BY
+         jobs.updated_at DESC
+    LIMIT :limit
+    """
+)
+
+# Same as above but filtered to only failed syncs
+SELECT_RECENT_FAILED_SYNCS_FOR_SOURCE_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS 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,
+         actor.tombstone AS actor_tombstone,
+         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
+    FROM jobs
+    JOIN connection
+      ON jobs.scope = connection.id::text
+     AND connection.status != 'deprecated'
+    JOIN actor
+      ON connection.source_id = actor.id
+     AND actor.actor_definition_id = :connector_definition_id
+     AND actor.tombstone = false
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    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
+         jobs.config_type = 'sync'
+     AND jobs.status = 'failed'
+     AND jobs.updated_at >= :cutoff_date
+    ORDER BY
+         jobs.updated_at DESC
+    LIMIT :limit
+    """
+)
+
+# Get recent sync results for ALL actors using a DESTINATION connector definition.
+SELECT_RECENT_SYNCS_FOR_DESTINATION_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS 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,
+         actor.tombstone AS actor_tombstone,
+         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
+    FROM jobs
+    JOIN connection
+      ON jobs.scope = connection.id::text
+     AND connection.status != 'deprecated'
+    JOIN actor
+      ON connection.destination_id = actor.id
+     AND actor.actor_definition_id = :connector_definition_id
+     AND actor.tombstone = false
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    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
+         jobs.config_type = 'sync'
+     AND jobs.updated_at >= :cutoff_date
+    ORDER BY
+         jobs.updated_at DESC
+    LIMIT :limit
+    """
+)
+
+# Same as above but filtered to only successful syncs
+SELECT_RECENT_SUCCESSFUL_SYNCS_FOR_DESTINATION_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS 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,
+         actor.tombstone AS actor_tombstone,
+         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
+    FROM jobs
+    JOIN connection
+      ON jobs.scope = connection.id::text
+     AND connection.status != 'deprecated'
+    JOIN actor
+      ON connection.destination_id = actor.id
+     AND actor.actor_definition_id = :connector_definition_id
+     AND actor.tombstone = false
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    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
+         jobs.config_type = 'sync'
+     AND jobs.status = 'succeeded'
+     AND jobs.updated_at >= :cutoff_date
+    ORDER BY
+         jobs.updated_at DESC
+    LIMIT :limit
+    """
+)
+
+# Same as above but filtered to only failed syncs
+SELECT_RECENT_FAILED_SYNCS_FOR_DESTINATION_CONNECTOR = sqlalchemy.text(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS 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,
+         actor.tombstone AS actor_tombstone,
+         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
+    FROM jobs
+    JOIN connection
+      ON jobs.scope = connection.id::text
+     AND connection.status != 'deprecated'
+    JOIN actor
+      ON connection.destination_id = actor.id
+     AND actor.actor_definition_id = :connector_definition_id
+     AND actor.tombstone = false
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+     AND workspace.tombstone = false
+    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
+         jobs.config_type = 'sync'
+     AND jobs.status = 'failed'
+     AND jobs.updated_at >= :cutoff_date
+    ORDER BY
+         jobs.updated_at DESC
+    LIMIT :limit
+    """
+)
+
 # 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.
@@ -527,3 +826,111 @@ SELECT_WORKSPACES_BY_EMAIL_DOMAIN = sqlalchemy.text(
     LIMIT :limit
     """
 )
+
+# =============================================================================
+# Connector Connection Stats Queries (Aggregate Counts)
+# =============================================================================
+
+# Count connections by SOURCE connector with latest attempt status breakdown
+# Groups by pinned version and provides counts of succeeded/failed/other attempts
+# Uses a CTE to get the latest attempt per connection, then aggregates
+SELECT_SOURCE_CONNECTION_STATS = sqlalchemy.text(
+    """
+    WITH latest_attempts AS (
+        SELECT DISTINCT ON (connection.id)
+            connection.id AS connection_id,
+            connection.status AS connection_status,
+            scoped_configuration.value AS pinned_version_id,
+            attempts.status::text AS latest_attempt_status
+        FROM connection
+        JOIN actor
+          ON connection.source_id = actor.id
+         AND actor.actor_definition_id = :connector_definition_id
+         AND actor.tombstone = false
+        JOIN workspace
+          ON actor.workspace_id = workspace.id
+         AND workspace.tombstone = false
+        LEFT JOIN scoped_configuration
+          ON scoped_configuration.scope_id = actor.id
+         AND scoped_configuration.key = 'connector_version'
+         AND scoped_configuration.scope_type = 'actor'
+        LEFT JOIN jobs
+          ON jobs.scope = connection.id::text
+         AND jobs.config_type = 'sync'
+         AND jobs.updated_at >= :cutoff_date
+        LEFT JOIN attempts
+          ON attempts.job_id = jobs.id
+        WHERE
+             connection.status != 'deprecated'
+        ORDER BY
+             connection.id,
+             attempts.ended_at DESC NULLS LAST
+    )
+    SELECT
+        pinned_version_id,
+        COUNT(*) AS total_connections,
+        COUNT(*) FILTER (WHERE connection_status = 'active') AS enabled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NOT NULL) AS active_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NOT NULL) AS pinned_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NULL) AS unpinned_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'succeeded') AS succeeded_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'failed') AS failed_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'cancelled') AS cancelled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'running') AS running_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NULL) AS unknown_connections
+    FROM latest_attempts
+    GROUP BY pinned_version_id
+    ORDER BY total_connections DESC
+    """
+)
+
+# Count connections by DESTINATION connector with latest attempt status breakdown
+SELECT_DESTINATION_CONNECTION_STATS = sqlalchemy.text(
+    """
+    WITH latest_attempts AS (
+        SELECT DISTINCT ON (connection.id)
+            connection.id AS connection_id,
+            connection.status AS connection_status,
+            scoped_configuration.value AS pinned_version_id,
+            attempts.status::text AS latest_attempt_status
+        FROM connection
+        JOIN actor
+          ON connection.destination_id = actor.id
+         AND actor.actor_definition_id = :connector_definition_id
+         AND actor.tombstone = false
+        JOIN workspace
+          ON actor.workspace_id = workspace.id
+         AND workspace.tombstone = false
+        LEFT JOIN scoped_configuration
+          ON scoped_configuration.scope_id = actor.id
+         AND scoped_configuration.key = 'connector_version'
+         AND scoped_configuration.scope_type = 'actor'
+        LEFT JOIN jobs
+          ON jobs.scope = connection.id::text
+         AND jobs.config_type = 'sync'
+         AND jobs.updated_at >= :cutoff_date
+        LEFT JOIN attempts
+          ON attempts.job_id = jobs.id
+        WHERE
+             connection.status != 'deprecated'
+        ORDER BY
+             connection.id,
+             attempts.ended_at DESC NULLS LAST
+    )
+    SELECT
+        pinned_version_id,
+        COUNT(*) AS total_connections,
+        COUNT(*) FILTER (WHERE connection_status = 'active') AS enabled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NOT NULL) AS active_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NOT NULL) AS pinned_connections,
+        COUNT(*) FILTER (WHERE pinned_version_id IS NULL) AS unpinned_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'succeeded') AS succeeded_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'failed') AS failed_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'cancelled') AS cancelled_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status = 'running') AS running_connections,
+        COUNT(*) FILTER (WHERE latest_attempt_status IS NULL) AS unknown_connections
+    FROM latest_attempts
+    GROUP BY pinned_version_id
+    ORDER BY total_connections DESC
+    """
+)

airbyte_ops_mcp/regression_tests/connection_secret_retriever.py

@@ -39,7 +39,6 @@ from airbyte_ops_mcp.connection_config_retriever import (
     ConnectionObject,
     retrieve_objects,
 )
-from airbyte_ops_mcp.gcp_auth import ensure_adc_credentials
 
 if TYPE_CHECKING:
     from airbyte_ops_mcp.regression_tests.connection_fetcher import ConnectionData
@@ -85,9 +84,6 @@ def retrieve_unmasked_config(
     Returns:
         The unmasked source config dict, or None if retrieval fails.
     """
-    # Ensure GCP credentials are available (supports GCP_PROD_DB_ACCESS_CREDENTIALS fallback)
-    ensure_adc_credentials()
-
     # Only request the source config - that's all we need for secrets
     requested_objects = [ConnectionObject.SOURCE_CONFIG]
 

airbyte_ops_mcp/regression_tests/connector_runner.py

@@ -105,16 +105,19 @@ class ConnectorRunner:
         if self.config is not None:
             config_path = temp_dir / self.CONFIG_FILE
             config_path.write_text(json.dumps(self.config))
+            config_path.chmod(0o666)
             self.logger.debug(f"Wrote config to {config_path}")
 
         if self.configured_catalog is not None:
             catalog_path = temp_dir / self.CATALOG_FILE
             catalog_path.write_text(self.configured_catalog.json())
+            catalog_path.chmod(0o666)
             self.logger.debug(f"Wrote catalog to {catalog_path}")
 
         if self.state is not None:
             state_path = temp_dir / self.STATE_FILE
             state_path.write_text(json.dumps(self.state))
+            state_path.chmod(0o666)
             self.logger.debug(f"Wrote state to {state_path}")
 
     def _build_docker_command(self, temp_dir: Path) -> list[str]:
@@ -135,7 +138,7 @@ class ConnectorRunner:
             "--name",
             container_name,
             "-v",
-            f"{temp_dir}:{self.DATA_DIR}:ro",
+            f"{temp_dir}:{self.DATA_DIR}",
         ]
 
         if self.proxy_url:
@@ -168,9 +171,10 @@ class ConnectorRunner:
 
         with tempfile.TemporaryDirectory() as temp_dir:
             temp_path = Path(temp_dir)
-            # Make temp directory world-readable so non-root container users can access it
-            # Many connector images run as non-root users (e.g., 'airbyte' user)
-            temp_path.chmod(0o755)
+            # Make temp directory world-writable so non-root container users can read/write
+            # Many connector images run as non-root users (e.g., 'airbyte' user) with
+            # different UIDs than the host user, so they need write access for config migration
+            temp_path.chmod(0o777)
             self._prepare_data_directory(temp_path)
 
             docker_cmd = self._build_docker_command(temp_path)