format

Author: NSHkr

lib/elixir_scope.ex

@@ -20,16 +20,21 @@ defmodule ElixirScope do
   @doc """
   Get the current status of all ElixirScope subsystems.
   """
-  @spec status() :: {:ok, %{
-          config: map(),
-          events: map(),
-          telemetry: map()
-        }} | {:error, Error.t()}
+  @spec status() ::
+          {:ok,
+           %{
+             config: map(),
+             events: map(),
+             telemetry: map()
+           }}
+          | {:error, Error.t()}
   def status do
     case Foundation.status() do
       {:ok, foundation_status} ->
         {:ok, foundation_status}
-      {:error, _} = error -> error
+
+      {:error, _} = error ->
+        error
     end
   end
 

lib/elixir_scope/foundation.ex

@@ -54,11 +54,12 @@ defmodule ElixirScope.Foundation do
     with {:ok, config_status} <- Config.status(),
          {:ok, events_status} <- Events.status(),
          {:ok, telemetry_status} <- Telemetry.status() do
-      {:ok, %{
-        config: config_status,
-        events: events_status,
-        telemetry: telemetry_status
-      }}
+      {:ok,
+       %{
+         config: config_status,
+         events: events_status,
+         telemetry: telemetry_status
+       }}
     else
       {:error, _} = error -> error
     end
@@ -106,8 +107,10 @@ defmodule ElixirScope.Foundation do
     # Stop services in reverse order
     # Let the supervision tree handle the actual shutdown
     case Process.whereis(ElixirScope.Foundation.Supervisor) do
-      nil -> :ok
-      pid -> 
+      nil ->
+        :ok
+
+      pid ->
         Supervisor.stop(pid, :normal)
         :ok
     end
@@ -140,6 +143,7 @@ defmodule ElixirScope.Foundation do
           elixir_version: System.version(),
           otp_release: System.otp_release()
         }
+
         {:ok, health_info}
 
       {:error, _} = error ->
@@ -150,7 +154,7 @@ defmodule ElixirScope.Foundation do
   ## Private Functions
 
   defp determine_overall_health(service_status) do
-    all_running = 
+    all_running =
       service_status
       |> Map.values()
       |> Enum.all?(fn status -> Map.get(status, :status) == :running end)

lib/elixir_scope/foundation/application.ex

@@ -11,9 +11,12 @@ defmodule ElixirScope.Foundation.Application do
   def start(_type, _args) do
     children = [
       # Core foundation services
-      {ElixirScope.Foundation.Services.ConfigServer, name: ElixirScope.Foundation.Services.ConfigServer},
-      {ElixirScope.Foundation.Services.EventStore, name: ElixirScope.Foundation.Services.EventStore},
-      {ElixirScope.Foundation.Services.TelemetryService, name: ElixirScope.Foundation.Services.TelemetryService},
+      {ElixirScope.Foundation.Services.ConfigServer,
+       name: ElixirScope.Foundation.Services.ConfigServer},
+      {ElixirScope.Foundation.Services.EventStore,
+       name: ElixirScope.Foundation.Services.EventStore},
+      {ElixirScope.Foundation.Services.TelemetryService,
+       name: ElixirScope.Foundation.Services.TelemetryService},
 
       # Task supervisor for dynamic tasks
       {Task.Supervisor, name: ElixirScope.Foundation.TaskSupervisor}

lib/elixir_scope/foundation/config.ex

@@ -203,21 +203,19 @@ defmodule ElixirScope.Foundation.Config do
     if path in updatable_paths() do
       update(path, value)
     else
-      {:error, Error.new(
-        error_type: :config_update_forbidden,
-        message: "Configuration path cannot be updated at runtime",
-        context: %{path: path, allowed_paths: updatable_paths()},
-        category: :config,
-        subcategory: :validation,
-        severity: :medium
-      )}
+      {:error,
+       Error.new(
+         error_type: :config_update_forbidden,
+         message: "Configuration path cannot be updated at runtime",
+         context: %{path: path, allowed_paths: updatable_paths()},
+         category: :config,
+         subcategory: :validation,
+         severity: :medium
+       )}
     end
   end
 end
 
-
-
-
 # defmodule ElixirScope.Foundation.Config do
 #   @moduledoc """
 #   Centralized configuration management for ElixirScope with robust error handling.
@@ -488,7 +486,6 @@ end
 #   end
 # end
 
-
 #   @impl GenServer
 #   def handle_call(:get_config, _from, config) do
 #     {:reply, config, config}
@@ -518,7 +515,6 @@ end
 #     {:reply, value, config}
 #   end
 
-
 # @impl GenServer
 # def handle_call({:update_config, path, value}, _from, config) do
 #   context = ErrorContext.new(__MODULE__, :handle_update, metadata: %{path: path, value: value})

lib/elixir_scope/foundation/contracts/telemetry.ex

@@ -21,7 +21,7 @@ defmodule ElixirScope.Foundation.Contracts.Telemetry do
   @doc """
   Measure execution time and emit results.
   """
-  @callback measure(event_name(), metadata(), (() -> result)) :: result when result: var
+  @callback measure(event_name(), metadata(), (-> result)) :: result when result: var
 
   @doc """
   Emit a counter metric.

lib/elixir_scope/foundation/events.ex

@@ -127,7 +127,8 @@ defmodule ElixirScope.Foundation.Events do
       iex> ElixirScope.Foundation.Events.function_entry(MyModule, :my_func, 2, [arg1, arg2])
       {:ok, %Event{event_type: :function_entry, ...}}
   """
-  @spec function_entry(module(), atom(), arity(), [term()], keyword()) :: {:ok, Event.t()} | {:error, Error.t()}
+  @spec function_entry(module(), atom(), arity(), [term()], keyword()) ::
+          {:ok, Event.t()} | {:error, Error.t()}
   def function_entry(module, function, arity, args, opts \\ []) do
     alias ElixirScope.Foundation.Logic.EventLogic
     EventLogic.create_function_entry(module, function, arity, args, opts)
@@ -141,10 +142,20 @@ defmodule ElixirScope.Foundation.Events do
       iex> ElixirScope.Foundation.Events.function_exit(MyModule, :my_func, 2, 123, :ok, 1000, :normal)
       {:ok, %Event{event_type: :function_exit, ...}}
   """
-  @spec function_exit(module(), atom(), arity(), pos_integer(), term(), non_neg_integer(), atom()) :: {:ok, Event.t()} | {:error, Error.t()}
+  @spec function_exit(module(), atom(), arity(), pos_integer(), term(), non_neg_integer(), atom()) ::
+          {:ok, Event.t()} | {:error, Error.t()}
   def function_exit(module, function, arity, call_id, result, duration_ns, exit_reason) do
     alias ElixirScope.Foundation.Logic.EventLogic
-    EventLogic.create_function_exit(module, function, arity, call_id, result, duration_ns, exit_reason)
+
+    EventLogic.create_function_exit(
+      module,
+      function,
+      arity,
+      call_id,
+      result,
+      duration_ns,
+      exit_reason
+    )
   end
 
   @doc """
@@ -155,7 +166,8 @@ defmodule ElixirScope.Foundation.Events do
       iex> ElixirScope.Foundation.Events.state_change(self(), :handle_call, old_state, new_state)
       {:ok, %Event{event_type: :state_change, ...}}
   """
-  @spec state_change(pid(), atom(), term(), term(), keyword()) :: {:ok, Event.t()} | {:error, Error.t()}
+  @spec state_change(pid(), atom(), term(), term(), keyword()) ::
+          {:ok, Event.t()} | {:error, Error.t()}
   def state_change(server_pid, callback, old_state, new_state, opts \\ []) do
     alias ElixirScope.Foundation.Logic.EventLogic
     EventLogic.create_state_change(server_pid, callback, old_state, new_state, opts)
@@ -288,6 +300,7 @@ defmodule ElixirScope.Foundation.Events do
         alias ElixirScope.Foundation.Logic.EventLogic
         chain = EventLogic.extract_correlation_chain(events, correlation_id)
         {:ok, chain}
+
       {:error, _} = error ->
         error
     end
@@ -328,8 +341,6 @@ defmodule ElixirScope.Foundation.Events do
   end
 end
 
-
-
 # defmodule ElixirScope.Foundation.Events do
 #   @moduledoc """
 #   Core event system for ElixirScope.

lib/elixir_scope/foundation/graceful_degradation.ex

@@ -145,7 +145,7 @@ defmodule ElixirScope.Foundation.Config.GracefulDegradation do
         cold: %{enable: false}
       },
       interface: %{query_timeout: 1000, max_results: 100, enable_streaming: false},
-      dev: %{debug_mode: false, verbose_logging: false, performance_monitoring: false},
+      dev: %{debug_mode: false, verbose_logging: false, performance_monitoring: false}
     }
   end
 end
@@ -184,11 +184,12 @@ defmodule ElixirScope.Foundation.Events.GracefulDegradation do
     IO.puts("📥 Input event: #{inspect(event_or_tuple, limit: :infinity)}")
 
     # Handle both Event structs and {:ok, Event} tuples
-    event = case event_or_tuple do
-      {:ok, %ElixirScope.Foundation.Types.Event{} = e} -> e
-      %ElixirScope.Foundation.Types.Event{} = e -> e
-      other -> other
-    end
+    event =
+      case event_or_tuple do
+        {:ok, %ElixirScope.Foundation.Types.Event{} = e} -> e
+        %ElixirScope.Foundation.Types.Event{} = e -> e
+        other -> other
+      end
 
     result =
       case Events.serialize(event) do
@@ -334,6 +335,7 @@ defmodule ElixirScope.Foundation.Events.GracefulDegradation do
   defp reconstruct_event_from_map(map) do
     # Attempt to reconstruct event from map
     alias ElixirScope.Foundation.Types.Event
+
     %Event{
       event_id: Map.get(map, "event_id", Utils.generate_id()),
       event_type: String.to_atom(Map.get(map, "event_type", "unknown")),
@@ -349,6 +351,7 @@ defmodule ElixirScope.Foundation.Events.GracefulDegradation do
 
   defp create_error_event(binary) do
     alias ElixirScope.Foundation.Types.Event
+
     %Event{
       event_id: Utils.generate_id(),
       event_type: :deserialization_error,

lib/elixir_scope/foundation/logic/config_logic.ex

@@ -154,6 +154,7 @@ defmodule ElixirScope.Foundation.Logic.ConfigLogic do
 
   defp deep_merge(left, right) when is_map(left) and is_list(right) do
     right_map = Enum.into(right, %{})
+
     Map.merge(left, right_map, fn _key, left_val, right_val ->
       deep_merge(left_val, right_val)
     end)
@@ -176,10 +177,13 @@ defmodule ElixirScope.Foundation.Logic.ConfigLogic do
       current_path = path ++ [key]
 
       cond do
-        old_val == new_val -> acc
+        old_val == new_val ->
+          acc
+
         is_map(old_val) and is_map(new_val) ->
           nested_diff = create_diff(old_val, new_val, current_path)
           if map_size(nested_diff) > 0, do: Map.put(acc, key, nested_diff), else: acc
+
         true ->
           Map.put(acc, key, %{old: old_val, new: new_val, path: current_path})
       end
@@ -195,14 +199,15 @@ defmodule ElixirScope.Foundation.Logic.ConfigLogic do
   end
 
   defp create_error(error_type, message, context) do
-    error = Error.new(
-      error_type: error_type,
-      message: message,
-      context: context,
-      category: :config,
-      subcategory: :runtime,
-      severity: :medium
-    )
+    error =
+      Error.new(
+        error_type: error_type,
+        message: message,
+        context: context,
+        category: :config,
+        subcategory: :runtime,
+        severity: :medium
+      )
 
     {:error, error}
   end

lib/elixir_scope/foundation/logic/event_logic.ex

@@ -18,17 +18,18 @@ defmodule ElixirScope.Foundation.Logic.EventLogic do
   """
   @spec create_event(atom(), term(), event_opts()) :: {:ok, Event.t()} | {:error, Error.t()}
   def create_event(event_type, data, opts \\ []) do
-    event = Event.new(
-      event_id: Keyword.get(opts, :event_id, Utils.generate_id()),
-      event_type: event_type,
-      timestamp: Keyword.get(opts, :timestamp, Utils.monotonic_timestamp()),
-      wall_time: Keyword.get(opts, :wall_time, DateTime.utc_now()),
-      node: Keyword.get(opts, :node, Node.self()),
-      pid: Keyword.get(opts, :pid, self()),
-      correlation_id: Keyword.get(opts, :correlation_id),
-      parent_id: Keyword.get(opts, :parent_id),
-      data: data
-    )
+    event =
+      Event.new(
+        event_id: Keyword.get(opts, :event_id, Utils.generate_id()),
+        event_type: event_type,
+        timestamp: Keyword.get(opts, :timestamp, Utils.monotonic_timestamp()),
+        wall_time: Keyword.get(opts, :wall_time, DateTime.utc_now()),
+        node: Keyword.get(opts, :node, Node.self()),
+        pid: Keyword.get(opts, :pid, self()),
+        correlation_id: Keyword.get(opts, :correlation_id),
+        parent_id: Keyword.get(opts, :parent_id),
+        data: data
+      )
 
     case EventValidator.validate(event) do
       :ok -> {:ok, event}
@@ -109,11 +110,12 @@ defmodule ElixirScope.Foundation.Logic.EventLogic do
     compression = Keyword.get(opts, :compression, true)
 
     try do
-      binary = if compression do
-        :erlang.term_to_binary(event, [:compressed])
-      else
-        :erlang.term_to_binary(event)
-      end
+      binary =
+        if compression do
+          :erlang.term_to_binary(event, [:compressed])
+        else
+          :erlang.term_to_binary(event)
+        end
 
       {:ok, binary}
     rescue
@@ -163,7 +165,8 @@ defmodule ElixirScope.Foundation.Logic.EventLogic do
   Extract correlation chain from a list of events.
   """
   @spec extract_correlation_chain([Event.t()], String.t()) :: [Event.t()]
-  def extract_correlation_chain(events, correlation_id) when is_list(events) and is_binary(correlation_id) do
+  def extract_correlation_chain(events, correlation_id)
+      when is_list(events) and is_binary(correlation_id) do
     events
     |> Enum.filter(fn event -> event.correlation_id == correlation_id end)
     |> Enum.sort_by(& &1.timestamp)
@@ -212,14 +215,15 @@ defmodule ElixirScope.Foundation.Logic.EventLogic do
   end
 
   defp create_error(error_type, message, context) do
-    error = Error.new(
-      error_type: error_type,
-      message: message,
-      context: context,
-      category: :data,
-      subcategory: :runtime,
-      severity: :medium
-    )
+    error =
+      Error.new(
+        error_type: error_type,
+        message: message,
+        context: context,
+        category: :data,
+        subcategory: :runtime,
+        severity: :medium
+      )
 
     {:error, error}
   end