feat: resolve adapter type from profiles.yml for transient error detection

- Add _get_adapter_type() method to CommandLineDbtRunner that parses
  dbt_project.yml and profiles.yml to resolve the actual adapter type
  (e.g. 'bigquery', 'snowflake') for the selected target.
- Pass adapter_type instead of self.target to is_transient_error(),
  ensuring correct per-adapter pattern matching.
- Remove duplicate 'databricks_catalog' entry from _ADAPTER_PATTERNS
  since profiles.yml always reports the adapter type, not the profile name.
- Update docstrings to reflect that target should be the adapter type.
- Gracefully falls back to None (check all patterns) if profiles cannot
  be parsed.

Co-Authored-By: Itamar Hartstein <haritamar@gmail.com>

Author: devin-ai-integration[bot]

elementary/clients/dbt/command_line_dbt_runner.py

@@ -84,13 +84,86 @@ def __init__(
             secret_vars,
             allow_macros_without_package_prefix,
         )
+        self.adapter_type = self._get_adapter_type()
         self.raise_on_failure = raise_on_failure
         self.env_vars = env_vars
         if force_dbt_deps:
             self.deps()
         elif run_deps_if_needed:
             self._run_deps_if_needed()
 
+    def _get_adapter_type(self) -> Optional[str]:
+        """Resolve the adapter type from dbt profile configuration.
+
+        Reads ``dbt_project.yml`` to find the profile name, then looks up
+        the selected target in ``profiles.yml`` to extract its ``type``
+        field (e.g. ``"bigquery"``, ``"snowflake"``).
+
+        Returns ``None`` when the adapter type cannot be determined (missing
+        files, missing keys, parse errors, etc.).
+        """
+        try:
+            # Read dbt_project.yml to get the profile name.
+            dbt_project_path = os.path.join(self.project_dir, "dbt_project.yml")
+            if not os.path.exists(dbt_project_path):
+                logger.debug("dbt_project.yml not found at %s", dbt_project_path)
+                return None
+
+            with open(dbt_project_path) as f:
+                dbt_project = yaml.safe_load(f)
+
+            profile_name = dbt_project.get("profile")
+            if not profile_name:
+                logger.debug("No profile name found in dbt_project.yml")
+                return None
+
+            # Determine profiles directory.
+            if self.profiles_dir:
+                profiles_dir = self.profiles_dir
+            else:
+                profiles_dir = os.path.join(os.path.expanduser("~"), ".dbt")
+
+            profiles_path = os.path.join(profiles_dir, "profiles.yml")
+            if not os.path.exists(profiles_path):
+                logger.debug("profiles.yml not found at %s", profiles_path)
+                return None
+
+            with open(profiles_path) as f:
+                profiles = yaml.safe_load(f)
+
+            profile = profiles.get(profile_name)
+            if not profile:
+                logger.debug("Profile '%s' not found in profiles.yml", profile_name)
+                return None
+
+            # Determine which target to use.
+            target_name = self.target if self.target else profile.get("target")
+            if not target_name:
+                logger.debug("No target specified and no default target in profile")
+                return None
+
+            outputs = profile.get("outputs", {})
+            target_config = outputs.get(target_name)
+            if not target_config:
+                logger.debug("Target '%s' not found in profile outputs", target_name)
+                return None
+
+            adapter_type = target_config.get("type")
+            if adapter_type:
+                logger.debug(
+                    "Resolved adapter type '%s' for target '%s'",
+                    adapter_type,
+                    target_name,
+                )
+            else:
+                logger.debug("No type found in target configuration")
+
+            return adapter_type
+
+        except Exception as exc:
+            logger.debug("Failed to resolve adapter type: %s", exc)
+            return None
+
     def _inner_run_command(
         self,
         dbt_command_args: List[str],
@@ -203,7 +276,9 @@ def _inner_run_command_with_retries(
                         if isinstance(exc.proc_err.stderr, bytes)
                         else str(exc.proc_err.stderr)
                     )
-            if is_transient_error(self.target, output=output_text, stderr=stderr_text):
+            if is_transient_error(
+                self.adapter_type, output=output_text, stderr=stderr_text
+            ):
                 raise DbtTransientError(
                     result=DbtCommandResult(
                         success=False,
@@ -225,7 +300,7 @@ def _inner_run_command_with_retries(
                     logger.info(log.msg)
 
         if not result.success and is_transient_error(
-            self.target, output=result.output, stderr=result.stderr
+            self.adapter_type, output=result.output, stderr=result.stderr
         ):
             raise DbtTransientError(
                 result=result,

elementary/clients/dbt/transient_errors.py

@@ -10,11 +10,11 @@
 substrings that appear in the error output.  Matching is
 case-insensitive substring search so regex is not needed.
 
-Note: The ``target`` argument accepted by :func:`is_transient_error` may
-be either the dbt adapter type *or* the profile target name (e.g.
-``"dev"``, ``"prod"``).  When it does not match any known adapter key,
-**all** adapter patterns are checked defensively.  This is safe because
-adapter-specific error messages only appear in output from that adapter.
+The ``target`` argument accepted by :func:`is_transient_error` should be
+the dbt **adapter type** (e.g. ``"bigquery"``, ``"snowflake"``), as
+resolved from ``profiles.yml``.  When the value does not match any known
+adapter key (or is ``None``), **all** adapter patterns are checked
+defensively so that transient errors are never missed.
 """
 
 from typing import Dict, Optional, Sequence, Tuple
@@ -76,7 +76,6 @@
         "ssl syscall error",
     ),
     "databricks": _DATABRICKS_PATTERNS,
-    "databricks_catalog": _DATABRICKS_PATTERNS,
     "athena": (
         "throttlingexception",
         "toomanyrequestsexception",
@@ -120,13 +119,12 @@ def is_transient_error(
     Parameters
     ----------
     target:
-        The dbt adapter type (e.g. ``"bigquery"``, ``"snowflake"``) **or**
-        the dbt profile target name (e.g. ``"dev"``, ``"prod"``).
+        The dbt adapter type (e.g. ``"bigquery"``, ``"snowflake"``),
+        typically resolved from ``profiles.yml`` by the runner.
         When the value matches a key in ``_ADAPTER_PATTERNS``, only that
         adapter's patterns (plus ``_COMMON``) are used.  When it does
-        **not** match any known adapter, **all** adapter patterns are
-        checked defensively to avoid missing transient errors.
-        When ``None``, all adapter patterns are checked defensively.
+        **not** match any known adapter (or is ``None``), **all** adapter
+        patterns are checked defensively to avoid missing transient errors.
     output:
         The captured stdout of the dbt command (may be ``None``).
     stderr: