dbg and qc

Author: nshkrdotcom

lib/pipeline/debug/nested_execution.ex

@@ -11,6 +11,9 @@ defmodule Pipeline.Debug.NestedExecution do
   alias Pipeline.Tracing.NestedExecution
   alias Pipeline.Error.NestedPipeline
 
+  # Import types from tracing module
+  @type trace_context :: Pipeline.Tracing.NestedExecution.trace_context()
+
   @type debug_session :: %{
           trace_context: map(),
           execution_tree: map(),
@@ -38,8 +41,13 @@ defmodule Pipeline.Debug.NestedExecution do
   ## Returns
   - Debug session context
   """
-  @spec start_debug_session(map(), map()) :: debug_session()
-  def start_debug_session(trace_context, options \\ %{}) do
+  @spec start_debug_session(trace_context()) :: debug_session()
+  def start_debug_session(trace_context) do
+    start_debug_session(trace_context, %{})
+  end
+
+  @spec start_debug_session(trace_context(), map()) :: debug_session()
+  def start_debug_session(trace_context, options) do
     session_id = generate_session_id()
     execution_tree = NestedExecution.build_execution_tree(trace_context)
 
@@ -152,8 +160,18 @@ defmodule Pipeline.Debug.NestedExecution do
   ## Returns
   - Comprehensive debugging report
   """
-  @spec generate_debug_report(map(), any(), map()) :: String.t()
-  def generate_debug_report(trace_context, error \\ nil, options \\ %{}) do
+  @spec generate_debug_report(trace_context()) :: String.t()
+  def generate_debug_report(trace_context) do
+    generate_debug_report(trace_context, nil, %{})
+  end
+
+  @spec generate_debug_report(trace_context(), any()) :: String.t()
+  def generate_debug_report(trace_context, error) do
+    generate_debug_report(trace_context, error, %{})
+  end
+
+  @spec generate_debug_report(trace_context(), any(), map()) :: String.t()
+  def generate_debug_report(trace_context, error, options) do
     execution_tree = NestedExecution.build_execution_tree(trace_context)
     analysis = analyze_execution(execution_tree, options)
 
@@ -179,8 +197,13 @@ defmodule Pipeline.Debug.NestedExecution do
   ## Returns
   - Formatted context information
   """
-  @spec inspect_context(map(), map()) :: String.t()
-  def inspect_context(context, step \\ nil) do
+  @spec inspect_context(map()) :: String.t()
+  def inspect_context(context) do
+    inspect_context(context, nil)
+  end
+
+  @spec inspect_context(map(), map() | nil) :: String.t()
+  def inspect_context(context, step) do
     """
     Context Inspection:
     ==================
@@ -202,10 +225,20 @@ defmodule Pipeline.Debug.NestedExecution do
     Execution Chain:
     #{format_execution_chain(context)}
 
-    Memory Usage: #{format_memory_usage()}
+    Memory Usage: #{format_memory_usage_inline()}
     """
   end
 
+  defp format_memory_usage_inline do
+    try do
+      memory_bytes = :erlang.memory(:total)
+      memory_mb = Float.round(memory_bytes / 1_048_576, 1)
+      "#{memory_mb} MB"
+    rescue
+      _ -> "Unknown"
+    end
+  end
+
   @doc """
   Compare execution performance between different traces.
 
@@ -851,20 +884,11 @@ defmodule Pipeline.Debug.NestedExecution do
     %{
       pipeline_id: Map.get(context, :pipeline_id, "unknown"),
       nesting_depth: Map.get(context, :nesting_depth, 0),
-      parent_context: Map.get(context, :parent_context)
+      parent_context: Map.get(context, :parent_context),
+      step_count: Map.get(context, :step_count, 0)
     }
   end
 
-  defp format_memory_usage do
-    try do
-      memory_bytes = :erlang.memory(:total)
-      memory_mb = Float.round(memory_bytes / 1_048_576, 1)
-      "#{memory_mb} MB"
-    rescue
-      _ -> "Unknown"
-    end
-  end
-
   defp format_comparison_table(summaries) do
     header = "Execution | Duration | Success Rate | Pipelines\n"
     separator = "----------|----------|--------------|----------\n"

lib/pipeline/error/nested_pipeline.ex

@@ -30,6 +30,29 @@ defmodule Pipeline.Error.NestedPipeline do
           debug_info: map()
         }
 
+  @type error_type ::
+          :circular_dependency | :not_found | :resource_limit | :timeout | :unknown | :validation
+
+  @type debug_log_entry :: %{
+          timestamp: DateTime.t(),
+          error_type: error_type(),
+          error_message: String.t(),
+          pipeline_id: String.t(),
+          nesting_depth: non_neg_integer(),
+          step_name: String.t() | nil,
+          step_type: String.t() | nil,
+          execution_chain: [String.t(), ...],
+          total_steps: non_neg_integer(),
+          elapsed_ms: integer(),
+          context_summary: %{
+            context_size: non_neg_integer(),
+            has_parent: boolean(),
+            key_count: non_neg_integer(),
+            nesting_depth: non_neg_integer()
+          },
+          step_config: map() | nil
+        }
+
   @doc """
   Format a nested pipeline error with comprehensive context information.
 
@@ -253,8 +276,13 @@ defmodule Pipeline.Error.NestedPipeline do
   ## Returns
   - Structured log entry map
   """
-  @spec create_debug_log_entry(any(), map(), map() | nil) :: map()
-  def create_debug_log_entry(error, context, step \\ nil) do
+  @spec create_debug_log_entry(any(), map()) :: debug_log_entry()
+  def create_debug_log_entry(error, context) do
+    create_debug_log_entry(error, context, nil)
+  end
+
+  @spec create_debug_log_entry(any(), map(), map() | nil) :: debug_log_entry()
+  def create_debug_log_entry(error, context, step) do
     safe_context = ensure_safe_context(context)
 
     %{

lib/pipeline/metrics/nested_performance.ex

@@ -663,9 +663,9 @@ defmodule Pipeline.Metrics.NestedPerformance do
         # < 1s
         d when d < 1000 -> 4
         # < 5s  
-        d when d < 5000 -> 3
+        d when d < 5_000 -> 3
         # < 30s
-        d when d < 30000 -> 2
+        d when d < 30_000 -> 2
         # > 30s
         _ -> 1
       end
@@ -684,7 +684,6 @@ defmodule Pipeline.Metrics.NestedPerformance do
         :good -> 3
         :fair -> 2
         :poor -> 1
-        _ -> 2
       end
 
     avg_score = (success_rate_score + duration_score + depth_score + resource_score) / 4

lib/pipeline/step/nested_pipeline.ex

@@ -262,10 +262,29 @@ defmodule Pipeline.Step.NestedPipeline do
             {:error, formatted_error}
         end
 
-      parent when not is_nil(parent) ->
+      _parent ->
         # For nested pipelines, check circular dependency against parent context,
         # then check other limits against current context
-        with :ok <- check_circular_dependency_with_parent(pipeline_name, parent),
+
+        # Inline circular dependency check to avoid dialyzer warning
+        circular_check_result =
+          case safety_context.parent_context do
+            nil ->
+              :ok
+
+            parent_ctx ->
+              # Ensure parent_context has the right structure for RecursionGuard
+              safe_parent = %{
+                nesting_depth: Map.get(parent_ctx, :nesting_depth, 0),
+                pipeline_id: Map.get(parent_ctx, :pipeline_id, "unknown"),
+                parent_context: Map.get(parent_ctx, :parent_context),
+                step_count: Map.get(parent_ctx, :step_count, 0)
+              }
+
+              Pipeline.Safety.RecursionGuard.check_circular_dependency(pipeline_name, safe_parent)
+          end
+
+        with :ok <- circular_check_result,
              :ok <- check_limits_for_current(safety_context, safety_config) do
           :ok
         else
@@ -364,16 +383,6 @@ defmodule Pipeline.Step.NestedPipeline do
   defp put_if_present(map, _key, nil), do: map
   defp put_if_present(map, key, value), do: Map.put(map, key, value)
 
-  # Check circular dependency using parent context
-  defp check_circular_dependency_with_parent(pipeline_name, parent_context) do
-    alias Pipeline.Safety.RecursionGuard
-
-    case RecursionGuard.check_circular_dependency(pipeline_name, parent_context) do
-      :ok -> :ok
-      {:error, message} -> {:error, message}
-    end
-  end
-
   # Check resource limits for current context only
   defp check_limits_for_current(safety_context, safety_config) do
     alias Pipeline.Safety.RecursionGuard
@@ -383,7 +392,15 @@ defmodule Pipeline.Step.NestedPipeline do
       max_total_steps: Map.get(safety_config, :max_total_steps, 1000)
     }
 
-    case RecursionGuard.check_limits(safety_context, recursion_limits) do
+    # Ensure safety_context has the right structure for RecursionGuard
+    safe_context = %{
+      nesting_depth: Map.get(safety_context, :nesting_depth, 0),
+      pipeline_id: Map.get(safety_context, :pipeline_id, "unknown"),
+      parent_context: Map.get(safety_context, :parent_context),
+      step_count: Map.get(safety_context, :step_count, 0)
+    }
+
+    case RecursionGuard.check_limits(safe_context, recursion_limits) do
       :ok -> :ok
       {:error, message} -> {:error, message}
     end

test/integration/nested_pipeline_phase4_test.exs

@@ -519,7 +519,7 @@ defmodule Pipeline.Integration.NestedPipelinePhase4Test do
         parent_context: %{pipeline_id: "parent", nesting_depth: 0, parent_context: nil}
       }
 
-      timeout_formatted = ErrorHandler.format_timeout_error(30, timeout_context, 35000)
+      timeout_formatted = ErrorHandler.format_timeout_error(30, timeout_context, 35_000)
       assert timeout_formatted =~ "timeout"
       assert timeout_formatted =~ "30s"
       assert timeout_formatted =~ "35.0s"

test/integration/workflow_scenarios_test.exs

@@ -174,7 +174,6 @@ defmodule Pipeline.WorkflowScenariosTest do
 
       case result do
         {:ok, results} ->
-          IO.inspect(results, label: "Workflow results")
           # Verify all steps completed successfully
           assert results["code_analysis"]["success"] == true
           assert results["generate_improvements"]["success"] == true

test/pipeline/debug/nested_execution_test.exs

@@ -151,12 +151,12 @@ defmodule Pipeline.Debug.NestedExecutionTest do
         pipeline_id: "slow_pipeline",
         spans: [
           # 10 seconds - slow
-          %{depth: 0, duration_ms: 10000, status: :completed},
+          %{depth: 0, duration_ms: 10_000, status: :completed},
           # 8 seconds - slow
-          %{depth: 1, duration_ms: 8000, status: :completed}
+          %{depth: 1, duration_ms: 8_000, status: :completed}
         ],
         children: [],
-        total_duration_ms: 18000,
+        total_duration_ms: 18_000,
         step_count: 2,
         max_depth: 1
       }

test/pipeline/error/nested_pipeline_test.exs

@@ -96,7 +96,7 @@ defmodule Pipeline.Error.NestedPipelineTest do
         parent_context: %{pipeline_id: "parent", nesting_depth: 0, parent_context: nil}
       }
 
-      result = NestedPipeline.format_timeout_error(30, context, 45000)
+      result = NestedPipeline.format_timeout_error(30, context, 45_000)
 
       assert result =~ "Pipeline execution timeout"
       assert result =~ "Limit: 30s"
@@ -109,7 +109,7 @@ defmodule Pipeline.Error.NestedPipelineTest do
     test "provides timeout troubleshooting guidance" do
       context = %{pipeline_id: "test", nesting_depth: 0, parent_context: nil}
 
-      result = NestedPipeline.format_timeout_error(10, context, 15000)
+      result = NestedPipeline.format_timeout_error(10, context, 15_000)
 
       assert result =~ "Long-running AI model calls"
       assert result =~ "Network connectivity issues"

test/pipeline/metrics/nested_performance_test.exs

@@ -319,8 +319,8 @@ defmodule Pipeline.Metrics.NestedPerformanceTest do
       performance_metrics = %{
         summary: %{overall_success_rate: 100.0, total_pipelines: 1, max_depth: 1},
         # Over 1 minute
-        pipeline_metrics: [%{duration_ms: 70000, step_count: 3}],
-        total_duration_ms: 70000,
+        pipeline_metrics: [%{duration_ms: 70_000, step_count: 3}],
+        total_duration_ms: 70_000,
         resource_metrics: %{peak_memory_mb: 100.0}
       }
 
@@ -451,7 +451,7 @@ defmodule Pipeline.Metrics.NestedPerformanceTest do
         # Very low success, deep nesting
         summary: %{overall_success_rate: 40.0, max_depth: 12, total_pipelines: 20},
         # Very slow
-        total_duration_ms: 45000,
+        total_duration_ms: 45_000,
         # High resource usage
         resource_metrics: %{peak_memory_mb: 2000.0, gc_collections: 50, process_count_peak: 200},
         pipeline_metrics: []
@@ -525,7 +525,7 @@ defmodule Pipeline.Metrics.NestedPerformanceTest do
       trace_id: "test_trace",
       start_time: DateTime.utc_now() |> DateTime.add(-10, :second),
       end_time: DateTime.utc_now(),
-      total_duration_ms: 10000,
+      total_duration_ms: 10_000,
       pipeline_metrics: [
         %{pipeline_id: "slow_pipeline", duration_ms: 8000, step_count: 5, success: true},
         %{pipeline_id: "fast_pipeline", duration_ms: 500, step_count: 2, success: true},