airbyte-internal-ops 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

{airbyte_internal_ops-0.1.8.dist-info → airbyte_internal_ops-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: airbyte-internal-ops
-Version: 0.1.8
+Version: 0.1.10
 Summary: MCP and API interfaces that let the agents do the admin work
 Author-email: Aaron Steers <aj@airbyte.io>
 Keywords: admin,airbyte,api,mcp

{airbyte_internal_ops-0.1.8.dist-info → airbyte_internal_ops-0.1.10.dist-info}/RECORD

@@ -1,6 +1,6 @@
 airbyte_ops_mcp/__init__.py,sha256=HhzURuYr29_UIdMrnWYaZB8ENr_kFkBdm4uqeiIW3Vw,760
 airbyte_ops_mcp/_annotations.py,sha256=MO-SBDnbykxxHDESG7d8rviZZ4WlZgJKv0a8eBqcEzQ,1757
-airbyte_ops_mcp/constants.py,sha256=419-AlRfwbbxeEEV9lhmXhpTUjsSdzJpfcuL_MZZtXM,1982
+airbyte_ops_mcp/constants.py,sha256=col6-5BUWuIYhbtKmlvSRR8URBoSNExoz94cn4_kujI,2333
 airbyte_ops_mcp/gcp_auth.py,sha256=5k-k145ZoYhHLjyDES8nrA8f8BBihRI0ykrdD1IcfOs,3599
 airbyte_ops_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_ops_mcp/_legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -207,7 +207,7 @@ airbyte_ops_mcp/_legacy/airbyte_ci/connector_qa/checks/documentation/templates/s
 airbyte_ops_mcp/_legacy/airbyte_ci/connector_qa/checks/documentation/templates/template.md.j2,sha256=bYxLfOP3GDwQC9Q3PiVbxsL5GS0p5b10k1dwzfOrm1M,1962
 airbyte_ops_mcp/_legacy/airbyte_ci/connector_qa/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 airbyte_ops_mcp/_legacy/airbyte_ci/connector_qa/templates/qa_checks.md.j2,sha256=v3NyYUAYkqRiYAFDQ2NgpgYK6PIDhDKrqfRgpX8454s,1946
-airbyte_ops_mcp/_legacy/airbyte_ci/metadata_models/README.md,sha256=9uGj0cTaGawoD-uMOT8ImT19XXozWz6-r_aFRjZhN8Y,3567
+airbyte_ops_mcp/_legacy/airbyte_ci/metadata_models/README.md,sha256=CQtTgVzHH3UdgRCohA9GyNhxIiYxVZmSwhMKWnfbocE,3569
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_models/package-lock.json,sha256=uazyPocrveknTDfwu4DlcaDQ5HwkPNf1Q_vDNpGMp0s,2233
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_models/package.json,sha256=_JMByXIhM9iYRKlLqheCVWXWswfwDzuXc5-A1VRUdUM,307
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_models/transform.py,sha256=cx-u9y0aYKs0M7rL47I62WQfcx6uIyzbL2wWv5GERNM,1939
@@ -282,7 +282,7 @@ airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/constants.py,sha256=bSXsx-RQ
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/docker_hub.py,sha256=K-6-QjTiSEPeJUnVJIMyYfTtu6uFoh0vLX579b04LSs,5528
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/gcs_upload.py,sha256=_r1nh54U6QFglFiPWBpxrSylE6Guu0Gjk7Bq5NKK4EE,26506
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/registry.py,sha256=3okT639PCZGL0p6tlWJoTYy-xI2igeAj6DerxkMC1_Q,15130
-airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/registry_entry.py,sha256=sVq0fgAnTIihROn9Iy5OHMswT-fF2JDTPsRo-bNF0yA,26417
+airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/registry_entry.py,sha256=QT-UopRiFGJpabvoya-B3F32qrlB2qluOiNKj56Pv4g,26489
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/registry_report.py,sha256=dp13BxBiXG7DgxhzfupMm-sTFdjUVn9TyYrvo6KShU0,12600
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/sentry.py,sha256=e1O6_FHrHvqNNQdb5TkXs5Bhv7_hZ8fMiOWJr8H5tkI,1806
 airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/spec_cache.py,sha256=rcsJtu6B8_bmfXFv9U-IVjsVpPDJWLJYdH8e_XbT7yk,4482
@@ -351,12 +351,12 @@ airbyte_ops_mcp/cli/__init__.py,sha256=XpL7FyVfgabfBF2JR7u7NwJ2krlYqjd_OwLcWf-Xc
 airbyte_ops_mcp/cli/_base.py,sha256=I8tWnyQf0ks4r3J8N8h-5GZxyn37T-55KsbuHnxYlcg,415
 airbyte_ops_mcp/cli/_shared.py,sha256=jg-xMyGzTCGPqKd8VTfE_3kGPIyO_3Kx5sQbG4rPc0Y,1311
 airbyte_ops_mcp/cli/app.py,sha256=SEdBpqFUG2O8zGV5ifwptxrLGFph_dLr66-MX9d69gQ,789
-airbyte_ops_mcp/cli/cloud.py,sha256=BMFYs5bTEgdOhxwzBrtSyYMKaHhXnMM_SGzK2hFDPBY,32076
+airbyte_ops_mcp/cli/cloud.py,sha256=semAuPqruWfe7JiVmtbELZgcpeqtoIn4LGD0kEvIS30,38981
 airbyte_ops_mcp/cli/gh.py,sha256=91b1AxFXvHQCFyXhrrym-756ZjnMCqvxFdmwCtma1zI,2046
-airbyte_ops_mcp/cli/registry.py,sha256=OpON1p4_A-G-FSfIpr6UlKYTjcj_zyiprKOu7qxwuhc,5787
+airbyte_ops_mcp/cli/registry.py,sha256=-yiLJWSslV_qGi6ImXZYfXOJSE4oJBO7yICkyA_RiUo,5792
 airbyte_ops_mcp/cli/repo.py,sha256=G1hoQpH0XYhUH3FFOsia9xabGB0LP9o3XcwBuqvFVo0,16331
 airbyte_ops_mcp/cloud_admin/__init__.py,sha256=cqE96Q10Kp6elhH9DAi6TVsIwSUy3sooDLLrxTaktGk,816
-airbyte_ops_mcp/cloud_admin/api_client.py,sha256=4vZv1J4S2Q8ETl6gIB20X1X6KHTVV-bx__b2Ax8oqyc,17358
+airbyte_ops_mcp/cloud_admin/api_client.py,sha256=6PovHDwOzo4fxSyk6viwvnXjCRIiC4uPZo0pGMx0Bdk,17359
 airbyte_ops_mcp/cloud_admin/auth.py,sha256=j45pRR8fg6CLwVdn7Uu5KW_kTz_CjRP6ZJGUzqHj_Dk,2558
 airbyte_ops_mcp/cloud_admin/connection_config.py,sha256=UtbIwuB7CA3WJr9oYRwlKDsjciqd_9ewWdml2f8DuXw,4887
 airbyte_ops_mcp/cloud_admin/models.py,sha256=YZ3FbEW-tZa50khKTTl4Bzvy_LsGyyQd6qcpXo62jls,2670
@@ -389,25 +389,25 @@ airbyte_ops_mcp/mcp/_mcp_utils.py,sha256=nhztHcoc-_ASPpJfoDBjxjjqEvQM6_QIrhp7F2U
 airbyte_ops_mcp/mcp/cloud_connector_versions.py,sha256=XxaS6WBP0sJPRwT7TTPhVH2PzhPqVWMNU5fVdWdxLLk,10361
 airbyte_ops_mcp/mcp/connector_analysis.py,sha256=OC4KrOSkMkKPkOisWnSv96BDDE5TQYHq-Jxa2vtjJpo,298
 airbyte_ops_mcp/mcp/connector_qa.py,sha256=aImpqdnqBPDrz10BS0owsV4kuIU2XdalzgbaGZsbOL0,258
-airbyte_ops_mcp/mcp/github.py,sha256=keB5_LUs6OULXr4Ukg-gzJfeDiC_QvBXSh56yTD9kSQ,7625
+airbyte_ops_mcp/mcp/github.py,sha256=opmVWRwjNs_jeWejv8wHOtb-3J09hOlqxg98GCzmFLo,7627
 airbyte_ops_mcp/mcp/github_repo_ops.py,sha256=PiERpt8abo20Gz4CfXhrDNlVM4o4FOt5sweZJND2a0s,5314
 airbyte_ops_mcp/mcp/live_tests.py,sha256=eHfgNkEcY1OKzYiJmkxwOluLPiFHIdP4nm_H1H0MXDg,17940
 airbyte_ops_mcp/mcp/metadata.py,sha256=fwGW97WknR5lfKcQnFtK6dU87aA6TmLj1NkKyqDAV9g,270
-airbyte_ops_mcp/mcp/prerelease.py,sha256=RTEq9uguaREeZ9BqC2In3abdGuqg2IUZZ43KNoYj66Y,9444
-airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=RV909zZX156WKXzwtu68Sd071tmaiJaCJz9wNHg3j0I,12399
+airbyte_ops_mcp/mcp/prerelease.py,sha256=08G6ogRqEauQyDxFLirUVaYeU3exAJd-DJn_8fXCNXg,9450
+airbyte_ops_mcp/mcp/prod_db_queries.py,sha256=RkBVISfkbwML3grWONxYsULRnFEYdqDZVBZIyo6W8xE,14311
 airbyte_ops_mcp/mcp/prompts.py,sha256=mJld9mdPECXYZffWXGSvNs4Xevx3rxqUGNlzGKVC2_s,1599
 airbyte_ops_mcp/mcp/registry.py,sha256=PW-VYUj42qx2pQ_apUkVaoUFq7VgB9zEU7-aGrkSCCw,290
 airbyte_ops_mcp/mcp/server.py,sha256=7zi91xioVTx1q-bEleekZH2c2JnbzDQt_6zxdEwnLbg,2958
 airbyte_ops_mcp/mcp/server_info.py,sha256=Yi4B1auW64QZGBDas5mro_vwTjvrP785TFNSBP7GhRg,2361
 airbyte_ops_mcp/prod_db_access/__init__.py,sha256=5pxouMPY1beyWlB0UwPnbaLTKTHqU6X82rbbgKY2vYU,1069
-airbyte_ops_mcp/prod_db_access/db_engine.py,sha256=ia1KcuQOXi3Qhy_MnxYmccCBJ4rAt_d4nVDjcyzje6o,4289
+airbyte_ops_mcp/prod_db_access/db_engine.py,sha256=11xNZTk4I8SKYhsnmE7-LVrkJXN4dCRbBeD1_hj3f-s,9027
 airbyte_ops_mcp/prod_db_access/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-airbyte_ops_mcp/prod_db_access/queries.py,sha256=jUGJErgDmaKf7mswgVEGin8bjsUFAxegSAOB47XzT9k,8724
-airbyte_ops_mcp/prod_db_access/sql.py,sha256=zHPucNuMlfxz3aU8vYo1ziiGk0lIncG9XmblEoRDd4c,12725
+airbyte_ops_mcp/prod_db_access/queries.py,sha256=q7PcI15EGh6jFS9MVB_gZt1a56YvrZV5hnwa5lgU2q0,10844
+airbyte_ops_mcp/prod_db_access/sql.py,sha256=tWQAwMk8DzG8HpLIYglljlReI2oeYulQPsV31ocUJSw,16251
 airbyte_ops_mcp/registry/__init__.py,sha256=iEaPlt9GrnlaLbc__98TguNeZG8wuQu7S-_2QkhHcbA,858
 airbyte_ops_mcp/registry/models.py,sha256=B4L4TKr52wo0xs0CqvCBrpowqjShzVnZ5eTr2-EyhNs,2346
 airbyte_ops_mcp/registry/publish.py,sha256=VoPxsM2_0zJ829orzCRN-kjgcJtuBNyXgW4I9J680ro,12717
-airbyte_internal_ops-0.1.8.dist-info/METADATA,sha256=BSNP1wsy5PbIFtyq6RbvCGPHgY3C8vC5UNsAzjqZAOk,5282
-airbyte_internal_ops-0.1.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-airbyte_internal_ops-0.1.8.dist-info/entry_points.txt,sha256=eUgJ9xIy9PlR-CgRbqRMsh1NVp6jz08v9bul9vCYlU4,111
-airbyte_internal_ops-0.1.8.dist-info/RECORD,,
+airbyte_internal_ops-0.1.10.dist-info/METADATA,sha256=I3WAz4JM1tgyGMcFaV5ElRwvwYjlRLR9kXKzifetd1Q,5283
+airbyte_internal_ops-0.1.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+airbyte_internal_ops-0.1.10.dist-info/entry_points.txt,sha256=eUgJ9xIy9PlR-CgRbqRMsh1NVp6jz08v9bul9vCYlU4,111
+airbyte_internal_ops-0.1.10.dist-info/RECORD,,

airbyte_ops_mcp/_legacy/airbyte_ci/metadata_models/README.md

@@ -75,7 +75,7 @@ This will copy the specified connector version to your development bucket. This
 _💡 Note: A prerequisite is you have [gsutil](https://cloud.google.com/storage/docs/gsutil) installed and have run `gsutil auth login`_
 
 ```bash
-TARGET_BUCKET=<YOUR-DEV_BUCKET> CONNECTOR="airbyte/source-stripe" VERSION="3.17.0-dev.ea013c8741" poetry run poe copy-connector-from-prod
+TARGET_BUCKET=<YOUR-DEV_BUCKET> CONNECTOR="airbyte/source-stripe" VERSION="3.17.0-preview.ea013c8" poetry run poe copy-connector-from-prod
 ```
 
 ### Promote Connector Version to Latest
@@ -87,5 +87,5 @@ _💡 Note: A prerequisite is you have [gsutil](https://cloud.google.com/storage
 _⚠️ Warning: Its important to know that this will remove ANY existing files in the latest folder that are not in the versioned folder as it calls `gsutil rsync` with `-d` enabled._
 
 ```bash
-TARGET_BUCKET=<YOUR-DEV_BUCKET> CONNECTOR="airbyte/source-stripe" VERSION="3.17.0-dev.ea013c8741" poetry run poe promote-connector-to-latest
+TARGET_BUCKET=<YOUR-DEV_BUCKET> CONNECTOR="airbyte/source-stripe" VERSION="3.17.0-preview.ea013c8" poetry run poe promote-connector-to-latest
 ```

airbyte_ops_mcp/_legacy/airbyte_ci/metadata_service/registry_entry.py

@@ -526,7 +526,7 @@ def generate_and_persist_registry_entry(
         bucket_name (str): The name of the GCS bucket.
         repo_metadata_file_path (pathlib.Path): The path to the spec file.
         registry_type (str): The registry type.
-        docker_image_tag (str): The docker image tag associated with this release. Typically a semver string (e.g. '1.2.3'), possibly with a suffix (e.g. '1.2.3-dev.abcde12345')
+        docker_image_tag (str): The docker image tag associated with this release. Typically a semver string (e.g. '1.2.3'), possibly with a suffix (e.g. '1.2.3-preview.abcde12')
         is_prerelease (bool): Whether this is a prerelease, or a main release.
     """
     # Read the repo metadata dict to bootstrap ourselves. We need the docker repository,
@@ -536,7 +536,7 @@ def generate_and_persist_registry_entry(
 
     try:
         # Now that we have the docker repo, read the appropriate versioned metadata from GCS.
-        # This metadata will differ in a few fields (e.g. in prerelease mode, dockerImageTag will contain the actual prerelease tag `1.2.3-dev.abcde12345`),
+        # This metadata will differ in a few fields (e.g. in prerelease mode, dockerImageTag will contain the actual prerelease tag `1.2.3-preview.abcde12`),
         # so we'll treat this as the source of truth (ish. See below for how we handle the registryOverrides field.)
         gcs_client = get_gcs_storage_client(gcs_creds=os.environ.get("GCS_CREDENTIALS"))
         bucket = gcs_client.bucket(bucket_name)
@@ -645,6 +645,7 @@ def generate_and_persist_registry_entry(
     if (
         "-rc" not in metadata_dict["data"]["dockerImageTag"]
         and "-dev" not in metadata_dict["data"]["dockerImageTag"]
+        and "-preview" not in metadata_dict["data"]["dockerImageTag"]
     ) and not metadata_dict["data"]["registryOverrides"][registry_type]["enabled"]:
         logger.info(
             f"{registry_type} is not enabled: deleting existing {registry_type} registry entry for {metadata_dict['data']['dockerRepository']} at latest path."

airbyte_ops_mcp/cli/cloud.py

@@ -13,6 +13,12 @@ Commands:
 from __future__ import annotations
 
 import json
+import os
+import shutil
+import signal
+import socket
+import subprocess
+import time
 from pathlib import Path
 from typing import Annotated, Literal
 
@@ -30,6 +36,12 @@ from airbyte_ops_mcp.cli._shared import (
     print_success,
 )
 from airbyte_ops_mcp.cloud_admin.connection_config import fetch_connection_config
+from airbyte_ops_mcp.constants import (
+    CLOUD_SQL_INSTANCE,
+    CLOUD_SQL_PROXY_PID_FILE,
+    DEFAULT_CLOUD_SQL_PROXY_PORT,
+    ENV_GCP_PROD_DB_ACCESS_CREDENTIALS,
+)
 from airbyte_ops_mcp.live_tests.ci_output import (
     generate_regression_report,
     get_report_summary,
@@ -75,6 +87,184 @@ connector_app = App(
 )
 cloud_app.command(connector_app)
 
+# Create the db sub-app under cloud
+db_app = App(name="db", help="Database operations for Airbyte Cloud Prod DB Replica.")
+cloud_app.command(db_app)
+
+
+@db_app.command(name="start-proxy")
+def start_proxy(
+    port: Annotated[
+        int,
+        Parameter(help="Port for the Cloud SQL Proxy to listen on."),
+    ] = DEFAULT_CLOUD_SQL_PROXY_PORT,
+    daemon: Annotated[
+        bool,
+        Parameter(
+            help="Run as daemon in background (default). Use --no-daemon for foreground."
+        ),
+    ] = True,
+) -> None:
+    """Start the Cloud SQL Proxy for database access.
+
+    This command starts the Cloud SQL Auth Proxy to enable connections to the
+    Airbyte Cloud Prod DB Replica. The proxy is required for database query tools.
+
+    By default, runs as a daemon (background process). Use --no-daemon to run in
+    foreground mode where you can see logs and stop with Ctrl+C.
+
+    Credentials are read from the GCP_PROD_DB_ACCESS_CREDENTIALS environment variable,
+    which should contain the service account JSON credentials.
+
+    After starting the proxy, set these environment variables to use database tools:
+        export USE_CLOUD_SQL_PROXY=1
+        export DB_PORT={port}
+
+    Example:
+        airbyte-ops cloud db start-proxy
+        airbyte-ops cloud db start-proxy --port 15432
+        airbyte-ops cloud db start-proxy --no-daemon
+    """
+    # Check if proxy is already running on the requested port (idempotency)
+    try:
+        with socket.create_connection(("127.0.0.1", port), timeout=0.5):
+            # Something is already listening on this port
+            pid_file = Path(CLOUD_SQL_PROXY_PID_FILE)
+            pid_info = ""
+            if pid_file.exists():
+                pid_info = f" (PID: {pid_file.read_text().strip()})"
+            print_success(
+                f"Cloud SQL Proxy is already running on port {port}{pid_info}"
+            )
+            print_success("")
+            print_success("To use database tools, set these environment variables:")
+            print_success("  export USE_CLOUD_SQL_PROXY=1")
+            print_success(f"  export DB_PORT={port}")
+            return
+    except (OSError, TimeoutError, ConnectionRefusedError):
+        pass  # Port not in use, proceed with starting proxy
+
+    # Check if cloud-sql-proxy is installed
+    proxy_path = shutil.which("cloud-sql-proxy")
+    if not proxy_path:
+        exit_with_error(
+            "cloud-sql-proxy not found in PATH. "
+            "Install it from: https://cloud.google.com/sql/docs/mysql/sql-proxy"
+        )
+
+    # Get credentials from environment
+    creds_json = os.getenv(ENV_GCP_PROD_DB_ACCESS_CREDENTIALS)
+    if not creds_json:
+        exit_with_error(
+            f"{ENV_GCP_PROD_DB_ACCESS_CREDENTIALS} environment variable is not set. "
+            "This should contain the GCP service account JSON credentials."
+        )
+
+    # Build the command using --json-credentials to avoid writing to disk
+    cmd = [
+        proxy_path,
+        CLOUD_SQL_INSTANCE,
+        f"--port={port}",
+        f"--json-credentials={creds_json}",
+    ]
+
+    print_success(f"Starting Cloud SQL Proxy on port {port}...")
+    print_success(f"Instance: {CLOUD_SQL_INSTANCE}")
+    print_success("")
+    print_success("To use database tools, set these environment variables:")
+    print_success("  export USE_CLOUD_SQL_PROXY=1")
+    print_success(f"  export DB_PORT={port}")
+    print_success("")
+
+    if daemon:
+        # Run in background (daemon mode) with log file for diagnostics
+        log_file_path = Path("/tmp/airbyte-cloud-sql-proxy.log")
+        log_file = log_file_path.open("ab")
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.DEVNULL,
+            stderr=log_file,
+            start_new_session=True,
+        )
+
+        # Brief wait to verify the process started successfully
+        time.sleep(0.5)
+        if process.poll() is not None:
+            # Process exited immediately - read any error output
+            log_file.close()
+            error_output = ""
+            if log_file_path.exists():
+                error_output = log_file_path.read_text()[-1000:]  # Last 1000 chars
+            exit_with_error(
+                f"Cloud SQL Proxy failed to start (exit code: {process.returncode}).\n"
+                f"Check logs at {log_file_path}\n"
+                f"Recent output: {error_output}"
+            )
+
+        # Write PID to file for stop-proxy command
+        pid_file = Path(CLOUD_SQL_PROXY_PID_FILE)
+        pid_file.write_text(str(process.pid))
+        print_success(f"Cloud SQL Proxy started as daemon (PID: {process.pid})")
+        print_success(f"Logs: {log_file_path}")
+        print_success("To stop: airbyte-ops cloud db stop-proxy")
+    else:
+        # Run in foreground - replace current process
+        # Signals (Ctrl+C) will be handled directly by the cloud-sql-proxy process
+        print_success("Running in foreground. Press Ctrl+C to stop the proxy.")
+        print_success("")
+        os.execv(proxy_path, cmd)
+
+
+@db_app.command(name="stop-proxy")
+def stop_proxy() -> None:
+    """Stop the Cloud SQL Proxy daemon.
+
+    This command stops a Cloud SQL Proxy that was started with 'start-proxy'.
+    It reads the PID from the PID file and sends a SIGTERM signal to stop the process.
+
+    Example:
+        airbyte-ops cloud db stop-proxy
+    """
+    pid_file = Path(CLOUD_SQL_PROXY_PID_FILE)
+
+    if not pid_file.exists():
+        exit_with_error(
+            f"PID file not found at {CLOUD_SQL_PROXY_PID_FILE}. "
+            "No Cloud SQL Proxy daemon appears to be running."
+        )
+
+    pid_str = pid_file.read_text().strip()
+    if not pid_str.isdigit():
+        pid_file.unlink()
+        exit_with_error(f"Invalid PID in {CLOUD_SQL_PROXY_PID_FILE}: {pid_str}")
+
+    pid = int(pid_str)
+
+    # Check if process is still running
+    try:
+        os.kill(pid, 0)  # Signal 0 just checks if process exists
+    except ProcessLookupError:
+        pid_file.unlink()
+        print_success(
+            f"Cloud SQL Proxy (PID: {pid}) is not running. Cleaned up PID file."
+        )
+        return
+    except PermissionError:
+        exit_with_error(f"Permission denied to check process {pid}.")
+
+    # Send SIGTERM to stop the process
+    try:
+        os.kill(pid, signal.SIGTERM)
+        print_success(f"Sent SIGTERM to Cloud SQL Proxy (PID: {pid}).")
+    except ProcessLookupError:
+        print_success(f"Cloud SQL Proxy (PID: {pid}) already stopped.")
+    except PermissionError:
+        exit_with_error(f"Permission denied to stop process {pid}.")
+
+    # Clean up PID file
+    pid_file.unlink(missing_ok=True)
+    print_success("Cloud SQL Proxy stopped.")
+
 
 @connector_app.command(name="get-version-info")
 def get_version_info(
@@ -117,7 +307,7 @@ def set_version_override(
     version: Annotated[
         str,
         Parameter(
-            help="The semver version string to pin to (e.g., '2.1.5-dev.abc1234567')."
+            help="The semver version string to pin to (e.g., '2.1.5-preview.abc1234')."
         ),
     ],
     reason: Annotated[

airbyte_ops_mcp/cli/registry.py

@@ -63,7 +63,7 @@ def publish_prerelease(
     """Publish a connector prerelease to the Airbyte registry.
 
     Triggers the publish-connectors-prerelease workflow in the airbytehq/airbyte
-    repository. Pre-release versions are tagged with format: {version}-dev.{git-sha}
+    repository. Pre-release versions are tagged with format: {version}-preview.{git-sha}
 
     Requires GITHUB_CONNECTOR_PUBLISHING_PAT or GITHUB_TOKEN environment variable
     with 'actions:write' permission.
@@ -162,7 +162,7 @@ def inspect_image(
     ],
     tag: Annotated[
         str,
-        Parameter(help="Image tag (e.g., '2.1.5-dev.abc1234567')."),
+        Parameter(help="Image tag (e.g., '2.1.5-preview.abc1234')."),
     ],
 ) -> None:
     """Check if a Docker image exists on DockerHub.

airbyte_ops_mcp/cloud_admin/api_client.py

@@ -160,7 +160,7 @@ def resolve_connector_version_id(
     Args:
         actor_definition_id: The actor definition ID
         connector_type: Either "source" or "destination"
-        version: The version string (e.g., "0.1.47-dev.abe7cb4ddb")
+        version: The version string (e.g., "0.1.47-preview.abe7cb4")
         api_root: The API root URL
         client_id: The Airbyte Cloud client ID
         client_secret: The Airbyte Cloud client secret

airbyte_ops_mcp/constants.py

@@ -27,6 +27,15 @@ EXPECTED_ADMIN_EMAIL_DOMAIN = "@airbyte.io"
 GCP_PROJECT_NAME = "prod-ab-cloud-proj"
 """The GCP project name for Airbyte Cloud production."""
 
+CLOUD_SQL_INSTANCE = "prod-ab-cloud-proj:us-west3:prod-pgsql-replica"
+"""The Cloud SQL instance connection name for the Prod DB Replica."""
+
+DEFAULT_CLOUD_SQL_PROXY_PORT = 15432
+"""Default port for Cloud SQL Proxy connections."""
+
+CLOUD_SQL_PROXY_PID_FILE = "/tmp/airbyte-cloud-sql-proxy.pid"
+"""PID file for tracking the Cloud SQL Proxy process."""
+
 CLOUD_REGISTRY_URL = (
     "https://connectors.airbyte.com/files/registries/v0/cloud_registry.json"
 )

airbyte_ops_mcp/mcp/github.py

@@ -204,7 +204,7 @@ def _check_dockerhub_image(
 
     Args:
         image: Docker image name (e.g., "airbyte/source-github")
-        tag: Image tag (e.g., "2.1.5-dev.abc1234567")
+        tag: Image tag (e.g., "2.1.5-preview.abc1234")
 
     Returns:
         Tag data dictionary if found, None if not found.
@@ -232,7 +232,7 @@ def get_docker_image_info(
     ],
     tag: Annotated[
         str,
-        Field(description="Image tag (e.g., '2.1.5-dev.abc1234567')"),
+        Field(description="Image tag (e.g., '2.1.5-preview.abc1234')"),
     ],
 ) -> DockerImageInfo:
     """Check if a Docker image exists on DockerHub.

airbyte_ops_mcp/mcp/prerelease.py

@@ -111,7 +111,7 @@ def _get_pr_head_info(
     return PRHeadInfo(
         ref=pr_data["head"]["ref"],
         sha=sha,
-        short_sha=sha[:10],
+        short_sha=sha[:7],
     )
 
 
@@ -235,7 +235,7 @@ def publish_connector_to_airbyte_registry(
     publish-connectors-prerelease workflow in the airbytehq/airbyte repository,
     which publishes a pre-release version of the specified connector from the PR branch.
 
-    Pre-release versions are tagged with the format: {version}-dev.{10-char-git-sha}
+    Pre-release versions are tagged with the format: {version}-preview.{7-char-git-sha}
     These versions are available for version pinning via the scoped_configuration API.
 
     Requires GITHUB_CONNECTOR_PUBLISHING_PAT or GITHUB_TOKEN environment variable
@@ -290,7 +290,7 @@ def publish_connector_to_airbyte_registry(
         docker_image = data.get("dockerRepository")
         base_version = data.get("dockerImageTag")
         if base_version:
-            docker_image_tag = f"{base_version}-dev.{head_info.short_sha}"
+            docker_image_tag = f"{base_version}-preview.{head_info.short_sha}"
 
     return PrereleaseWorkflowResult(
         success=True,

airbyte_ops_mcp/mcp/prod_db_queries.py

@@ -20,6 +20,7 @@ from airbyte_ops_mcp.prod_db_access.queries import (
     query_connections_by_connector,
     query_connector_versions,
     query_dataplanes_list,
+    query_failed_sync_attempts_for_version,
     query_new_connector_releases,
     query_sync_results_for_version,
     query_workspace_info,
@@ -245,6 +246,52 @@ def query_prod_connector_version_sync_results(
     )
 
 
+@mcp_tool(
+    read_only=True,
+    idempotent=True,
+)
+def query_prod_failed_sync_attempts_for_version(
+    connector_version_id: Annotated[
+        str,
+        Field(description="Connector version UUID to find failed sync attempts for"),
+    ],
+    days: Annotated[
+        int,
+        Field(description="Number of days to look back (default: 7)", default=7),
+    ] = 7,
+    limit: Annotated[
+        int,
+        Field(description="Maximum number of results (default: 100)", default=100),
+    ] = 100,
+) -> list[dict[str, Any]]:
+    """List failed sync attempts with failure details for actors pinned to a connector version.
+
+    Returns failed attempt records for connections using actors pinned to the specified
+    version. Includes failure_summary from the attempts table for debugging.
+
+    Key fields:
+    - latest_job_attempt_status: Final job status after all retries ('succeeded' means
+      the job eventually succeeded despite this failed attempt)
+    - failed_attempt_number: Which attempt this was (0-indexed)
+    - failure_summary: JSON containing failure details including failureType and messages
+
+    Note: May return multiple rows per job (one per failed attempt). Results ordered by
+    job_updated_at DESC, then failed_attempt_number DESC.
+
+    Returns list of dicts with keys: job_id, connection_id, latest_job_attempt_status,
+    job_started_at, job_updated_at, connection_name, actor_id, actor_name,
+    actor_definition_id, pin_origin_type, pin_origin, workspace_id, workspace_name,
+    organization_id, dataplane_group_id, dataplane_name, failed_attempt_id,
+    failed_attempt_number, failed_attempt_status, failed_attempt_created_at,
+    failed_attempt_ended_at, failure_summary, processing_task_queue
+    """
+    return query_failed_sync_attempts_for_version(
+        connector_version_id,
+        days=days,
+        limit=limit,
+    )
+
+
 @mcp_tool(
     read_only=True,
     idempotent=True,

airbyte_ops_mcp/prod_db_access/db_engine.py

@@ -11,7 +11,9 @@ from __future__ import annotations
 
 import json
 import os
-import traceback
+import shutil
+import socket
+import subprocess
 from typing import Any, Callable
 
 import sqlalchemy
@@ -21,9 +23,127 @@ from google.cloud.sql.connector.enums import IPTypes
 
 from airbyte_ops_mcp.constants import (
     CONNECTION_RETRIEVER_PG_CONNECTION_DETAILS_SECRET_ID,
+    DEFAULT_CLOUD_SQL_PROXY_PORT,
 )
 
 PG_DRIVER = "pg8000"
+PROXY_CHECK_TIMEOUT = 0.5  # seconds
+DIRECT_CONNECTION_TIMEOUT = 5  # seconds - timeout for direct VPC/Tailscale connections
+
+
+class CloudSqlProxyNotRunningError(Exception):
+    """Raised when proxy mode is enabled but the Cloud SQL Proxy is not running."""
+
+    pass
+
+
+class VpnNotConnectedError(Exception):
+    """Raised when direct connection mode requires VPN but it's not connected."""
+
+    pass
+
+
+def _is_tailscale_connected() -> bool:
+    """Check if Tailscale VPN is likely connected.
+
+    This is a best-effort check that works on Linux and macOS.
+    Returns True if Tailscale appears to be connected, False otherwise.
+
+    Detection methods:
+    1. Check for tailscale0 network interface (Linux)
+    2. Run 'tailscale status --json' and check backend state (cross-platform)
+    """
+    # Method 1: Check for tailscale0 interface (Linux)
+    try:
+        interfaces = [name for _, name in socket.if_nameindex()]
+        if "tailscale0" in interfaces:
+            return True
+    except (OSError, AttributeError):
+        pass  # if_nameindex not available on this platform
+
+    # Method 2: Check tailscale CLI status
+    tailscale_path = shutil.which("tailscale")
+    if tailscale_path:
+        try:
+            result = subprocess.run(
+                [tailscale_path, "status", "--json"],
+                capture_output=True,
+                text=True,
+                timeout=2,
+            )
+            if result.returncode == 0:
+                import json as json_module
+
+                status = json_module.loads(result.stdout)
+                # BackendState "Running" indicates connected
+                return status.get("BackendState") == "Running"
+        except (subprocess.TimeoutExpired, subprocess.SubprocessError, ValueError):
+            pass
+
+    return False
+
+
+def _check_vpn_or_proxy_available() -> None:
+    """Check if either VPN or proxy is available for database access.
+
+    This function checks if the environment is properly configured for
+    database access. It fails fast with a helpful error message if neither
+    Tailscale VPN nor the Cloud SQL Proxy appears to be available.
+
+    Raises:
+        VpnNotConnectedError: If no VPN or proxy is detected
+    """
+    # If proxy mode is explicitly enabled, don't check VPN
+    if os.getenv("CI") or os.getenv("USE_CLOUD_SQL_PROXY"):
+        return
+
+    # Check if Tailscale is connected
+    if _is_tailscale_connected():
+        return
+
+    # Neither proxy mode nor Tailscale detected
+    raise VpnNotConnectedError(
+        "No VPN or proxy detected for database access.\n\n"
+        "To connect to the Airbyte Cloud Prod DB Replica, you need either:\n\n"
+        "1. Tailscale VPN connected (for direct VPC access)\n"
+        "   - Install Tailscale: https://tailscale.com/download\n"
+        "   - Connect to the Airbyte network\n\n"
+        "2. Cloud SQL Proxy running locally\n"
+        "   - Start the proxy:\n"
+        "       airbyte-ops cloud db start-proxy\n"
+        "       uvx --from=airbyte-internal-ops airbyte-ops cloud db start-proxy\n"
+        "   - Set env vars: export USE_CLOUD_SQL_PROXY=1 DB_PORT=15432\n"
+    )
+
+
+def _check_proxy_is_running(host: str, port: int) -> None:
+    """Check if the Cloud SQL Proxy is running and accepting connections.
+
+    This performs a quick socket connection check to fail fast if the proxy
+    is not running, rather than waiting for a long connection timeout.
+
+    Args:
+        host: The host to connect to (typically 127.0.0.1)
+        port: The port to connect to
+
+    Raises:
+        CloudSqlProxyNotRunningError: If the proxy is not accepting connections
+    """
+    try:
+        with socket.create_connection((host, port), timeout=PROXY_CHECK_TIMEOUT):
+            pass  # Connection successful, proxy is running
+    except (OSError, TimeoutError, ConnectionRefusedError) as e:
+        raise CloudSqlProxyNotRunningError(
+            f"Cloud SQL Proxy is not running on {host}:{port}. "
+            f"Proxy mode is enabled (CI or USE_CLOUD_SQL_PROXY env var is set), "
+            f"but nothing is listening on the expected port.\n\n"
+            f"To start the proxy, run:\n"
+            f"  airbyte-ops cloud db start-proxy --port {port}\n"
+            f"  uvx --from=airbyte-internal-ops airbyte-ops cloud db start-proxy --port {port}\n\n"
+            f"Or unset USE_CLOUD_SQL_PROXY to use direct VPC connection.\n\n"
+            f"Original error: {e}"
+        ) from e
+
 
 # Lazy-initialized to avoid import-time GCP auth
 _connector: Connector | None = None
@@ -81,16 +201,20 @@ def get_pool(
     """Get a SQLAlchemy connection pool for the Airbyte Cloud database.
 
     This function supports two connection modes:
-    1. Direct connection via Cloud SQL Python Connector (default, requires VPC access)
+    1. Direct connection via Cloud SQL Python Connector (default, requires VPC/Tailscale)
     2. Connection via Cloud SQL Auth Proxy (when CI or USE_CLOUD_SQL_PROXY env var is set)
 
     For proxy mode, start the proxy with:
-        cloud-sql-proxy prod-ab-cloud-proj:us-west3:prod-pgsql-replica --port=<port>
+        airbyte-ops cloud db start-proxy
 
     Environment variables:
         CI: If set, uses proxy connection mode
         USE_CLOUD_SQL_PROXY: If set, uses proxy connection mode
-        DB_PORT: Port for proxy connection (default: 5432)
+        DB_PORT: Port for proxy connection (default: 15432)
+
+    Raises:
+        VpnNotConnectedError: If direct mode is used but no VPN/proxy is detected
+        CloudSqlProxyNotRunningError: If proxy mode is enabled but the proxy is not running
 
     Args:
         gsm_client: GCP Secret Manager client for retrieving credentials
@@ -98,6 +222,9 @@ def get_pool(
     Returns:
         SQLAlchemy Engine connected to the Prod DB Replica
     """
+    # Fail fast if no VPN or proxy is available
+    _check_vpn_or_proxy_available()
+
     pg_connection_details = json.loads(
         _get_secret_value(
             gsm_client, CONNECTION_RETRIEVER_PG_CONNECTION_DETAILS_SECRET_ID
@@ -106,21 +233,21 @@ def get_pool(
 
     if os.getenv("CI") or os.getenv("USE_CLOUD_SQL_PROXY"):
         # Connect via Cloud SQL Auth Proxy, running on localhost
-        # Port can be configured via DB_PORT env var (default: 5432)
+        # Port can be configured via DB_PORT env var (default: DEFAULT_CLOUD_SQL_PROXY_PORT)
         host = "127.0.0.1"
-        port = os.getenv("DB_PORT", "5432")
-        try:
-            return sqlalchemy.create_engine(
-                f"postgresql+{PG_DRIVER}://{pg_connection_details['pg_user']}:{pg_connection_details['pg_password']}@{host}:{port}/{pg_connection_details['database_name']}",
-            )
-        except Exception as e:
-            raise AssertionError(
-                f"sqlalchemy.create_engine exception; could not connect to the proxy at {host}:{port}. "
-                f"Error: {traceback.format_exception(e)}"
-            ) from e
+        port = int(os.getenv("DB_PORT", str(DEFAULT_CLOUD_SQL_PROXY_PORT)))
+
+        # Fail fast if proxy is not running
+        _check_proxy_is_running(host, port)
+
+        return sqlalchemy.create_engine(
+            f"postgresql+{PG_DRIVER}://{pg_connection_details['pg_user']}:{pg_connection_details['pg_password']}@{host}:{port}/{pg_connection_details['database_name']}",
+        )
 
-    # Default: Connect via Cloud SQL Python Connector (requires VPC access)
+    # Default: Connect via Cloud SQL Python Connector (requires VPC/Tailscale access)
+    # Use a timeout to fail faster if the connection can't be established
     return sqlalchemy.create_engine(
         f"postgresql+{PG_DRIVER}://",
         creator=get_database_creator(pg_connection_details),
+        connect_args={"timeout": DIRECT_CONNECTION_TIMEOUT},
     )

airbyte_ops_mcp/prod_db_access/queries.py

@@ -21,8 +21,10 @@ from airbyte_ops_mcp.prod_db_access.db_engine import get_pool
 from airbyte_ops_mcp.prod_db_access.sql import (
     SELECT_ACTORS_PINNED_TO_VERSION,
     SELECT_CONNECTIONS_BY_CONNECTOR,
+    SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
     SELECT_CONNECTOR_VERSIONS,
     SELECT_DATAPLANES_LIST,
+    SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION,
     SELECT_NEW_CONNECTOR_RELEASES,
     SELECT_ORG_WORKSPACES,
     SELECT_SUCCESSFUL_SYNCS_FOR_VERSION,
@@ -85,14 +87,28 @@ def query_connections_by_connector(
     Returns:
         List of connection records with workspace and dataplane info
     """
+    # Use separate queries to avoid pg8000 NULL parameter type issues
+    # pg8000 cannot determine the type of NULL parameters in patterns like
+    # "(:param IS NULL OR column = :param)"
+    if organization_id is None:
+        return _run_sql_query(
+            SELECT_CONNECTIONS_BY_CONNECTOR,
+            parameters={
+                "connector_definition_id": connector_definition_id,
+                "limit": limit,
+            },
+            query_name="SELECT_CONNECTIONS_BY_CONNECTOR",
+            gsm_client=gsm_client,
+        )
+
     return _run_sql_query(
-        SELECT_CONNECTIONS_BY_CONNECTOR,
+        SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG,
         parameters={
             "connector_definition_id": connector_definition_id,
             "organization_id": organization_id,
             "limit": limit,
         },
-        query_name="SELECT_CONNECTIONS_BY_CONNECTOR",
+        query_name="SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG",
         gsm_client=gsm_client,
     )
 
@@ -209,6 +225,44 @@ def query_sync_results_for_version(
     )
 
 
+def query_failed_sync_attempts_for_version(
+    connector_version_id: str,
+    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.
+
+    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.
+
+    Note: This may return multiple rows per job (one per attempt). Results are
+    ordered by job_updated_at DESC, then attempt_number DESC.
+
+    Args:
+        connector_version_id: Connector version UUID to filter by
+        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
+    """
+    cutoff_date = datetime.now(timezone.utc) - timedelta(days=days)
+    return _run_sql_query(
+        SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION,
+        parameters={
+            "actor_definition_version_id": connector_version_id,
+            "cutoff_date": cutoff_date,
+            "limit": limit,
+        },
+        query_name="SELECT_FAILED_SYNC_ATTEMPTS_FOR_VERSION",
+        gsm_client=gsm_client,
+    )
+
+
 def query_dataplanes_list(
     *,
     gsm_client: secretmanager.SecretManagerServiceClient | None = None,

airbyte_ops_mcp/prod_db_access/sql.py

@@ -74,7 +74,9 @@ import sqlalchemy
 # Connection Queries
 # =============================================================================
 
-# Query connections by connector type, optionally filtered by organization
+# Query connections by connector type (no organization filter)
+# Note: pg8000 cannot determine the type of NULL parameters in patterns like
+# "(:param IS NULL OR column = :param)", so we use separate queries instead
 SELECT_CONNECTIONS_BY_CONNECTOR = sqlalchemy.text(
     """
     SELECT
@@ -97,7 +99,34 @@ SELECT_CONNECTIONS_BY_CONNECTOR = sqlalchemy.text(
       ON workspace.dataplane_group_id = dataplane_group.id
     WHERE
          source_actor.actor_definition_id = :connector_definition_id
-     AND (:organization_id IS NULL OR workspace.organization_id = :organization_id)
+    LIMIT :limit
+    """
+)
+
+# Query connections by connector type, filtered by organization
+SELECT_CONNECTIONS_BY_CONNECTOR_AND_ORG = sqlalchemy.text(
+    """
+    SELECT
+         connection.id AS connection_id,
+         connection.name AS connection_name,
+         connection.source_id,
+         workspace.id AS workspace_id,
+         workspace.name AS workspace_name,
+         workspace.organization_id,
+         workspace.dataplane_group_id,
+         dataplane_group.name AS dataplane_name,
+         source_actor.actor_definition_id AS source_definition_id,
+         source_actor.name AS source_name
+    FROM connection
+    JOIN actor AS source_actor
+      ON connection.source_id = source_actor.id
+    JOIN workspace
+      ON source_actor.workspace_id = workspace.id
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         source_actor.actor_definition_id = :connector_definition_id
+     AND workspace.organization_id = :organization_id
     LIMIT :limit
     """
 )
@@ -276,6 +305,66 @@ 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(
+    """
+    SELECT
+         jobs.id AS job_id,
+         jobs.scope AS connection_id,
+         jobs.status AS latest_job_attempt_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,
+         attempts.id AS failed_attempt_id,
+         attempts.attempt_number AS failed_attempt_number,
+         attempts.status AS failed_attempt_status,
+         attempts.created_at AS failed_attempt_created_at,
+         attempts.ended_at AS failed_attempt_ended_at,
+         attempts.failure_summary,
+         attempts.processing_task_queue
+    FROM attempts
+    JOIN jobs
+      ON jobs.id = attempts.job_id
+     AND jobs.config_type = 'sync'
+     AND jobs.updated_at >= :cutoff_date
+    JOIN connection
+      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
+    JOIN workspace
+      ON actor.workspace_id = workspace.id
+    LEFT JOIN dataplane_group
+      ON workspace.dataplane_group_id = dataplane_group.id
+    WHERE
+         attempts.ended_at >= :cutoff_date
+     AND attempts.status = 'failed'
+    ORDER BY
+         attempts.ended_at DESC
+    LIMIT :limit
+    """
+)
+
 # =============================================================================
 # Dataplane and Workspace Queries
 # =============================================================================