Formatting

Author: khamilowicz

bundlex.exs

@@ -22,7 +22,13 @@ defmodule Unifex.BundlexProject do
       ],
       unifex: [
         src_base: "unifex/cnode/unifex",
-        sources: ["unifex.c", "cnode.c", "payload.c", "../../unifex/logger.c", "../../unifex/logger_cnode.c"],
+        sources: [
+          "unifex.c",
+          "cnode.c",
+          "payload.c",
+          "../../unifex/logger.c",
+          "../../unifex/logger_cnode.c"
+        ],
         includes: [Path.join(__DIR__, "c_src/unifex")],
         libs: ["pthread"],
         interface: :cnode

lib/unifex/logger.ex

@@ -30,7 +30,11 @@ defmodule Unifex.Logger do
   def handle_info({:unifex_logger, level, message, timestamp, tags}, state) do
     metadata = [tags: tags, unifex_nif: true, timestamp: timestamp]
 
-    Logger.log(normalize_level(level), fn -> format_message(message, tags, timestamp) end, metadata)
+    Logger.log(
+      normalize_level(level),
+      fn -> format_message(message, tags, timestamp) end,
+      metadata
+    )
 
     {:noreply, state}
   end

test/unifex/logger_integration_test.exs

@@ -8,20 +8,23 @@ defmodule Unifex.LoggerIntegrationTest do
     unless Process.whereis(Unifex.Logger) do
       {:ok, _pid} = Unifex.Logger.start_link([])
     end
+
     :ok
   end
 
   describe "Unifex.Logger integration with native code" do
-
     @tag :integration
     test "logger process handles messages from native code" do
       # This test would require a native function that calls unifex_log()
       # For now, we'll test that the logger process can handle direct messages
       pid = Process.whereis(Unifex.Logger)
-      
+
       # Send a message directly to the logger
-      send(pid, {:unifex_logger, :info, "Test message", 1700000000000000, ["test", "direct"]})
-      
+      send(
+        pid,
+        {:unifex_logger, :info, "Test message", 1_700_000_000_000_000, ["test", "direct"]}
+      )
+
       # The logger should process it without crashing
       assert Process.alive?(pid)
     end
@@ -30,7 +33,7 @@ defmodule Unifex.LoggerIntegrationTest do
     test "logger normalizes all valid Elixir log levels" do
       for level <- @valid_levels do
         pid = Process.whereis(Unifex.Logger)
-        send(pid, {:unifex_logger, level, "Test message", 1700000000000000, ["test"]})
+        send(pid, {:unifex_logger, level, "Test message", 1_700_000_000_000_000, ["test"]})
         assert Process.alive?(pid)
       end
     end
@@ -39,36 +42,41 @@ defmodule Unifex.LoggerIntegrationTest do
     test "logger handles string level from C code" do
       # The C code uses string levels like "debug", "info", "warning", "error"
       pid = Process.whereis(Unifex.Logger)
-      
+
       # Test each of the UNIFEX_LOG_LEVEL_ constants
       for level <- ["debug", "info", "warning", "error"] do
-        send(pid, {:unifex_logger, level, "Test message", 1700000000000000, ["test"]})
+        send(pid, {:unifex_logger, level, "Test message", 1_700_000_000_000_000, ["test"]})
         assert Process.alive?(pid)
       end
     end
 
     @tag :integration
     test "logger handles unknown levels gracefully" do
       pid = Process.whereis(Unifex.Logger)
-      
+
       # Send a message with an unknown level
-      send(pid, {:unifex_logger, :unknown_level, "Test message", 1700000000000000, ["test"]})
-      
+      send(pid, {:unifex_logger, :unknown_level, "Test message", 1_700_000_000_000_000, ["test"]})
+
       # Should still be alive and should have logged a warning about unknown level
       assert Process.alive?(pid)
     end
 
     @tag :integration
     test "logger handles messages with empty tags" do
       pid = Process.whereis(Unifex.Logger)
-      send(pid, {:unifex_logger, :info, "Test message", 1700000000000000, []})
+      send(pid, {:unifex_logger, :info, "Test message", 1_700_000_000_000_000, []})
       assert Process.alive?(pid)
     end
 
     @tag :integration
     test "logger handles messages with nil tags" do
       pid = Process.whereis(Unifex.Logger)
-      send(pid, {:unifex_logger, :info, "Test message", 1700000000000000, [nil, "valid", nil]})
+
+      send(
+        pid,
+        {:unifex_logger, :info, "Test message", 1_700_000_000_000_000, [nil, "valid", nil]}
+      )
+
       assert Process.alive?(pid)
     end
   end
@@ -83,4 +91,4 @@ defmodule Unifex.LoggerIntegrationTest do
       assert Process.alive?(pid)
     end
   end
-end
+end

test/unifex/logger_test.exs

@@ -35,19 +35,21 @@ defmodule Unifex.LoggerTest do
     end
 
     test "formats message without tags" do
-      timestamp = 1700000000000000  # microseconds since epoch
+      # microseconds since epoch
+      timestamp = 1_700_000_000_000_000
       message = "Test message"
       tags = []
 
       formatted = Unifex.Logger.format_message(message, tags, timestamp)
 
       # Should contain the message and timestamp
       assert String.contains?(formatted, message)
-      assert String.contains?(formatted, "2023-11-14")  # Approximate date for timestamp
+      # Approximate date for timestamp
+      assert String.contains?(formatted, "2023-11-14")
     end
 
     test "formats message with tags" do
-      timestamp = 1700000000000000
+      timestamp = 1_700_000_000_000_000
       message = "Test message"
       tags = ["tag1", "tag2"]
 
@@ -60,19 +62,21 @@ defmodule Unifex.LoggerTest do
 
     test "formats timestamp correctly" do
       # Test with a known timestamp
-      timestamp = 1700000000000000  # 2023-11-14T22:13:20.000000Z
+      # 2023-11-14T22:13:20.000000Z
+      timestamp = 1_700_000_000_000_000
       formatted_timestamp = Unifex.Logger.format_timestamp(timestamp)
       assert formatted_timestamp == "2023-11-14T22:13:20.000000Z"
     end
 
     test "handles nil tags gracefully" do
-      timestamp = 1700000000000000
+      timestamp = 1_700_000_000_000_000
       message = "Test message"
       tags = [nil, "valid_tag", nil]
 
       formatted = Unifex.Logger.format_message(message, tags, timestamp)
 
-      assert String.contains?(formatted, "[]")  # nil tags become empty brackets
+      # nil tags become empty brackets
+      assert String.contains?(formatted, "[]")
       assert String.contains?(formatted, "[valid_tag]")
     end
 
@@ -84,7 +88,7 @@ defmodule Unifex.LoggerTest do
           # Send a log message directly to the logger process
           level = :info
           message = "Test integration message"
-          timestamp = 1700000000000000
+          timestamp = 1_700_000_000_000_000
           tags = ["integration", "test"]
 
           send(pid, {:unifex_logger, level, message, timestamp, tags})
@@ -96,8 +100,14 @@ defmodule Unifex.LoggerTest do
         end
       else
         {:ok, pid} = Unifex.Logger.start_link([])
+
         try do
-          send(pid, {:unifex_logger, :info, "Test integration message", 1700000000000000, ["integration", "test"]})
+          send(
+            pid,
+            {:unifex_logger, :info, "Test integration message", 1_700_000_000_000_000,
+             ["integration", "test"]}
+          )
+
           assert Process.alive?(pid)
         after
           GenServer.stop(pid)
@@ -117,6 +127,7 @@ defmodule Unifex.LoggerTest do
         end
       else
         {:ok, pid} = Unifex.Logger.start_link([])
+
         try do
           send(pid, {:unknown, :message})
           assert Process.alive?(pid)
@@ -134,7 +145,7 @@ defmodule Unifex.LoggerTest do
       # #define UNIFEX_LOG_LEVEL_INFO "info"
       # #define UNIFEX_LOG_LEVEL_WARN "warning"
       # #define UNIFEX_LOG_LEVEL_ERROR "error"
-      
+
       # We verify that these atom values are valid Elixir logger levels
       # (note: the C code sends string levels which get normalized to atoms)
       assert :debug in @valid_levels
@@ -143,4 +154,4 @@ defmodule Unifex.LoggerTest do
       assert :error in @valid_levels
     end
   end
-end
+end