infrastructure initial implementation. 30 properties, 400 tests, 0 failures, 39 excluded

Author: NSHkr

.dialyzer.ignore.exs

@@ -0,0 +1,16 @@
+[
+  # circuit_breaker.ex contract_supertype warnings
+  {"lib/elixir_scope/foundation/infrastructure/circuit_breaker.ex", :contract_supertype},
+  
+  # connection_manager.ex contract_supertype warnings  
+  {"lib/elixir_scope/foundation/infrastructure/connection_manager.ex", :contract_supertype},
+  
+  # infrastructure.ex contract_supertype warnings
+  {"lib/elixir_scope/foundation/infrastructure/infrastructure.ex", :contract_supertype},
+  
+  # rate_limiter.ex contract_supertype warnings
+  {"lib/elixir_scope/foundation/infrastructure/rate_limiter.ex", :contract_supertype},
+  
+  # pool_workers contract_supertype warnings
+  {"lib/elixir_scope/foundation/infrastructure/pool_workers/http_worker.ex", :contract_supertype}
+]

lib/elixir_scope/application.ex

@@ -22,6 +22,11 @@ defmodule ElixirScope.Application do
       {ElixirScope.Foundation.Services.EventStore, [namespace: :production]},
       {ElixirScope.Foundation.Services.TelemetryService, [namespace: :production]},
 
+      # Infrastructure protection components
+      {ElixirScope.Foundation.Infrastructure.ConnectionManager, []},
+      {ElixirScope.Foundation.Infrastructure.RateLimiter.HammerBackend,
+       [clean_period: :timer.minutes(1)]},
+
       # Task supervisor for dynamic tasks
       {Task.Supervisor, name: ElixirScope.Foundation.TaskSupervisor}
 

lib/elixir_scope/foundation/infrastructure/circuit_breaker.ex

@@ -0,0 +1,349 @@
+defmodule ElixirScope.Foundation.Infrastructure.CircuitBreaker do
+  @moduledoc """
+  Circuit breaker wrapper around :fuse library.
+
+  Provides standardized circuit breaker functionality with telemetry integration
+  and ElixirScope-specific error handling. Translates :fuse errors to 
+  Foundation.Types.Error structures.
+
+  ## Usage
+
+      # Start a fuse instance
+      {:ok, _pid} = CircuitBreaker.start_fuse_instance(:my_service, options)
+      
+      # Execute protected operation
+      case CircuitBreaker.execute(:my_service, fn -> risky_operation() end) do
+        {:ok, result} -> result
+        {:error, error} -> handle_error(error)
+      end
+      
+      # Check circuit status
+      status = CircuitBreaker.get_status(:my_service)
+  """
+
+  alias ElixirScope.Foundation.Types.Error
+  alias ElixirScope.Foundation.Telemetry
+
+  @type fuse_name :: atom()
+  @type fuse_options :: [
+          strategy: :standard | :fault_injection,
+          tolerance: non_neg_integer(),
+          refresh: non_neg_integer()
+        ]
+  @type operation :: (-> any())
+  @type operation_result :: {:ok, any()} | {:error, Error.t()}
+
+  @doc """
+  Start a new fuse instance with the given name and options.
+
+  ## Parameters
+  - `name`: Unique atom identifier for the fuse
+  - `options`: Fuse configuration options
+
+  ## Examples
+
+      iex> CircuitBreaker.start_fuse_instance(:database, 
+      ...>   strategy: :standard, tolerance: 5, refresh: 60_000)
+      {:ok, #PID<0.123.0>}
+  """
+  @spec start_fuse_instance(fuse_name(), fuse_options()) :: :ok | {:error, Error.t()}
+  def start_fuse_instance(name, options \\ []) when is_atom(name) do
+    default_options = {{:standard, 5, 60_000}, {:reset, 60_000}}
+
+    fuse_options =
+      case options do
+        [] ->
+          default_options
+
+        [strategy: :standard, tolerance: tolerance, refresh: refresh] ->
+          {{:standard, tolerance, refresh}, {:reset, refresh}}
+
+        _ ->
+          default_options
+      end
+
+    try do
+      case :fuse.install(name, fuse_options) do
+        :ok ->
+          emit_telemetry(:fuse_installed, %{name: name, options: fuse_options})
+          :ok
+
+        {:error, :already_installed} ->
+          emit_telemetry(:fuse_already_installed, %{name: name})
+          :ok
+
+        {:error, reason} ->
+          error =
+            Error.new(
+              code: 5001,
+              error_type: :circuit_breaker_install_failed,
+              message: "Failed to install circuit breaker: #{inspect(reason)}",
+              severity: :high,
+              context: %{fuse_name: name, reason: reason}
+            )
+
+          emit_telemetry(:fuse_install_failed, %{name: name, reason: reason})
+          {:error, error}
+      end
+    rescue
+      exception ->
+        error =
+          Error.new(
+            code: 5002,
+            error_type: :circuit_breaker_exception,
+            message: "Exception during fuse installation: #{inspect(exception)}",
+            severity: :critical,
+            context: %{fuse_name: name, exception: exception}
+          )
+
+        emit_telemetry(:fuse_install_exception, %{name: name, exception: exception})
+        {:error, error}
+    end
+  end
+
+  @doc """
+  Execute an operation protected by the circuit breaker.
+
+  ## Parameters
+  - `name`: Fuse instance name
+  - `operation`: Function to execute
+  - `metadata`: Additional telemetry metadata
+
+  ## Examples
+
+      iex> CircuitBreaker.execute(:database, fn -> DB.query("SELECT 1") end)
+      {:ok, [%{column: 1}]}
+      
+      iex> CircuitBreaker.execute(:failing_service, fn -> raise "boom" end)
+      {:error, %Error{error_type: :circuit_breaker_blown}}
+  """
+  @spec execute(fuse_name(), operation(), map()) :: operation_result()
+  def execute(name, operation, metadata \\ %{}) when is_atom(name) and is_function(operation, 0) do
+    start_time = System.monotonic_time(:microsecond)
+
+    try do
+      case :fuse.ask(name, :sync) do
+        :ok ->
+          # Circuit is closed, execute operation
+          try do
+            result = operation.()
+            duration = System.monotonic_time(:microsecond) - start_time
+
+            emit_telemetry(
+              :call_executed,
+              Map.merge(metadata, %{
+                name: name,
+                duration: duration,
+                status: :success
+              })
+            )
+
+            {:ok, result}
+          rescue
+            exception ->
+              # Operation failed, melt the fuse
+              :fuse.melt(name)
+              duration = System.monotonic_time(:microsecond) - start_time
+
+              error =
+                Error.new(
+                  code: 5003,
+                  error_type: :protected_operation_failed,
+                  message: "Protected operation failed: #{inspect(exception)}",
+                  severity: :medium,
+                  context: %{fuse_name: name, exception: exception}
+                )
+
+              emit_telemetry(
+                :call_executed,
+                Map.merge(metadata, %{
+                  name: name,
+                  duration: duration,
+                  status: :failed,
+                  exception: exception
+                })
+              )
+
+              {:error, error}
+          end
+
+        :blown ->
+          # Circuit is open
+          error =
+            Error.new(
+              code: 5004,
+              error_type: :circuit_breaker_blown,
+              message: "Circuit breaker is open for #{name}",
+              severity: :medium,
+              context: %{fuse_name: name},
+              retry_strategy: :fixed_delay
+            )
+
+          emit_telemetry(
+            :call_rejected,
+            Map.merge(metadata, %{
+              name: name,
+              reason: :circuit_blown
+            })
+          )
+
+          {:error, error}
+
+        {:error, :not_found} ->
+          # Fuse not installed
+          error =
+            Error.new(
+              code: 5005,
+              error_type: :circuit_breaker_not_found,
+              message: "Circuit breaker #{name} not found",
+              severity: :high,
+              context: %{fuse_name: name}
+            )
+
+          emit_telemetry(
+            :call_rejected,
+            Map.merge(metadata, %{
+              name: name,
+              reason: :not_found
+            })
+          )
+
+          {:error, error}
+      end
+    rescue
+      exception ->
+        duration = System.monotonic_time(:microsecond) - start_time
+
+        error =
+          Error.new(
+            code: 5006,
+            error_type: :circuit_breaker_exception,
+            message: "Exception in circuit breaker execution: #{inspect(exception)}",
+            severity: :critical,
+            context: %{fuse_name: name, exception: exception}
+          )
+
+        emit_telemetry(
+          :call_executed,
+          Map.merge(metadata, %{
+            name: name,
+            duration: duration,
+            status: :exception,
+            exception: exception
+          })
+        )
+
+        {:error, error}
+    end
+  end
+
+  @doc """
+  Get the current status of a circuit breaker.
+
+  ## Parameters
+  - `name`: Fuse instance name
+
+  ## Returns
+  - `:ok` - Circuit is closed (healthy)
+  - `:blown` - Circuit is open (unhealthy)  
+  - `{:error, Error.t()}` - Fuse not found or other error
+
+  ## Examples
+
+      iex> CircuitBreaker.get_status(:my_service)
+      :ok
+      
+      iex> CircuitBreaker.get_status(:blown_service) 
+      :blown
+  """
+  @spec get_status(fuse_name()) :: :ok | :blown | {:error, Error.t()}
+  def get_status(name) when is_atom(name) do
+    try do
+      case :fuse.ask(name, :sync) do
+        :ok ->
+          :ok
+
+        :blown ->
+          :blown
+
+        {:error, :not_found} ->
+          error =
+            Error.new(
+              code: 5007,
+              error_type: :circuit_breaker_not_found,
+              message: "Circuit breaker #{name} not found",
+              severity: :medium,
+              context: %{fuse_name: name}
+            )
+
+          {:error, error}
+      end
+    rescue
+      exception ->
+        error =
+          Error.new(
+            code: 5008,
+            error_type: :circuit_breaker_exception,
+            message: "Exception checking circuit breaker status: #{inspect(exception)}",
+            severity: :medium,
+            context: %{fuse_name: name, exception: exception}
+          )
+
+        {:error, error}
+    end
+  end
+
+  @doc """
+  Reset a blown circuit breaker manually.
+
+  ## Parameters
+  - `name`: Fuse instance name
+
+  ## Examples
+
+      iex> CircuitBreaker.reset(:my_service)
+      :ok
+  """
+  @spec reset(fuse_name()) :: :ok | {:error, Error.t()}
+  def reset(name) when is_atom(name) do
+    try do
+      case :fuse.reset(name) do
+        :ok ->
+          emit_telemetry(:state_change, %{name: name, new_state: :reset})
+          :ok
+
+        {:error, :not_found} ->
+          error =
+            Error.new(
+              code: 5009,
+              error_type: :circuit_breaker_not_found,
+              message: "Cannot reset circuit breaker #{name}: not found",
+              severity: :medium,
+              context: %{fuse_name: name}
+            )
+
+          {:error, error}
+      end
+    rescue
+      exception ->
+        error =
+          Error.new(
+            code: 5010,
+            error_type: :circuit_breaker_exception,
+            message: "Exception resetting circuit breaker: #{inspect(exception)}",
+            severity: :medium,
+            context: %{fuse_name: name, exception: exception}
+          )
+
+        {:error, error}
+    end
+  end
+
+  # Private helper functions
+
+  @spec emit_telemetry(atom(), map()) :: :ok
+  defp emit_telemetry(event_type, metadata) do
+    event_name = [:elixir_scope, :foundation, :infra, :circuit_breaker, event_type]
+    Telemetry.emit_counter(event_name, metadata)
+  end
+end