familia 2.0.0.pre10 → 2.0.0.pre13

data/lib/familia/horreum/core/serialization.rb

@@ -470,7 +470,7 @@ module Familia
         # If the distinguisher returns nil, try using the dump_method but only
         # use JSON serialization for complex types that need it.
         if prepared.nil? && (val.is_a?(Hash) || val.is_a?(Array))
-          prepared = val.respond_to?(dump_method) ? val.send(dump_method) : JSON.dump(val)
+          prepared = val.respond_to?(dump_method) ? val.send(dump_method) : Familia::JsonSerializer.dump(val)
         end
 
         # If both the distinguisher and dump_method return nil, log an error
@@ -493,11 +493,11 @@ module Familia
 
         # Try to parse as JSON first for complex types
         begin
-          parsed = JSON.parse(val, symbolize_names: symbolize)
+          parsed = Familia::JsonSerializer.parse(val, symbolize_names: symbolize)
           # Only return parsed value if it's a complex type (Hash/Array)
           # Simple values should remain as strings
           return parsed if parsed.is_a?(Hash) || parsed.is_a?(Array)
-        rescue JSON::ParserError
+        rescue Familia::SerializerError
           # Not valid JSON, return as-is
         end
 

data/lib/familia/horreum/subclass/definition.rb

@@ -46,6 +46,8 @@ module Familia
       include Familia::Settings
       include Familia::Horreum::RelatedFieldsManagement # Provides DataType field methods
 
+      using Familia::Refinements::SnakeCase
+
       # Sets or retrieves the unique identifier field for the class.
       #
       # This method defines or returns the field or method that contains the unique
@@ -183,10 +185,7 @@ module Familia
       #
       # @return [String] The underscored class name as a string
       def config_name
-        name.split('::').last
-            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            .downcase
+        name.snake_case
       end
 
       def dump_method
@@ -237,10 +236,36 @@ module Familia
         field_types[field_type.name] = field_type
       end
 
-      # Get feature options for a specific feature or all features
+      # Retrieves feature options for the current class.
+      #
+      # Feature options are stored **per-class** in instance variables, ensuring
+      # complete isolation between different Familia::Horreum subclasses. Each
+      # class maintains its own @feature_options hash that does not interfere
+      # with other classes' configurations.
+      #
+      # @param feature_name [Symbol, String, nil] the name of the feature to get options for.
+      #   If nil, returns the entire feature options hash for this class.
+      # @return [Hash] the feature options hash, either for a specific feature or all features
+      #
+      # @example Getting options for a specific feature
+      #   class MyModel < Familia::Horreum
+      #     feature :object_identifier, generator: :uuid_v4
+      #   end
+      #
+      #   MyModel.feature_options(:object_identifier) #=> {generator: :uuid_v4}
+      #   MyModel.feature_options                     #=> {object_identifier: {generator: :uuid_v4}}
+      #
+      # @example Per-class isolation
+      #   class UserModel < Familia::Horreum
+      #     feature :object_identifier, generator: :uuid_v4
+      #   end
       #
-      # @param feature_name [Symbol, nil] The feature name to get options for
-      # @return [Hash] The options hash for the feature, or empty hash if none
+      #   class SessionModel < Familia::Horreum
+      #     feature :object_identifier, generator: :hex
+      #   end
+      #
+      #   UserModel.feature_options(:object_identifier)    #=> {generator: :uuid_v4}
+      #   SessionModel.feature_options(:object_identifier) #=> {generator: :hex}
       #
       def feature_options(feature_name = nil)
         @feature_options ||= {}
@@ -255,10 +280,28 @@ module Familia
       # without worrying about initialization state. Similar to register_field_type
       # for field types.
       #
+      # Feature options are stored at the **class level** using instance variables,
+      # ensuring complete isolation between different Familia::Horreum subclasses.
+      # Each class maintains its own @feature_options hash.
+      #
       # @param feature_name [Symbol] The feature name
       # @param options [Hash] The options to add/merge
       # @return [Hash] The updated options for the feature
       #
+      # @note This method only sets defaults for options that don't already exist,
+      #   using the ||= operator to prevent overwrites.
+      #
+      # @example Per-class storage behavior
+      #   class ModelA < Familia::Horreum
+      #     # This stores options in ModelA's @feature_options
+      #     add_feature_options(:my_feature, key: 'value_a')
+      #   end
+      #
+      #   class ModelB < Familia::Horreum
+      #     # This stores options in ModelB's @feature_options (separate from ModelA)
+      #     add_feature_options(:my_feature, key: 'value_b')
+      #   end
+      #
       def add_feature_options(feature_name, **options)
   @feature_options ||= {}
   @feature_options[feature_name.to_sym] ||= {}

data/lib/familia/horreum.rb

@@ -31,6 +31,8 @@ module Familia
     include Familia::Horreum::Core
     include Familia::Horreum::Settings
 
+    using Familia::Refinements::TimeUtils
+
     # Singleton Class Context
     #
     # The code within this block operates on the singleton class (also known as

data/lib/familia/json_serializer.rb

@@ -0,0 +1,70 @@
+# lib/familia/json_serializer.rb
+
+module Familia
+  # JsonSerializer provides a high-performance JSON interface using OJ
+  #
+  # This module wraps OJ with a clean API that can be easily swapped out
+  # or benchmarked against other JSON implementations. Uses OJ's :strict
+  # mode for RFC 7159 compliant JSON output.
+  #
+  # @example Basic usage
+  #   data = { name: 'test', value: 123 }
+  #   json = Familia::JsonSerializer.dump(data)
+  #   parsed = Familia::JsonSerializer.parse(json, symbolize_names: true)
+  #
+  module JsonSerializer
+
+    class << self
+      # Parse JSON string into Ruby objects
+      #
+      # @param source [String] JSON string to parse
+      # @param opts [Hash] parsing options
+      # @option opts [Boolean] :symbolize_names convert hash keys to symbols
+      # @return [Object] parsed Ruby object
+      # @raise [SerializerError] if JSON is malformed
+      def parse(source, opts = {})
+        return nil if source.nil? || source == ''
+
+        symbolize_names = opts[:symbolize_names] || opts['symbolize_names']
+
+        if symbolize_names
+          Oj.load(source, mode: :strict, symbol_keys: true)
+        else
+          Oj.load(source, mode: :strict)
+        end
+      rescue Oj::ParseError, Oj::Error, EncodingError => e
+        raise SerializerError, e.message
+      end
+
+      # Serialize Ruby object to JSON string
+      #
+      # @param obj [Object] Ruby object to serialize
+      # @return [String] JSON string
+      def dump(obj)
+        Oj.dump(obj, mode: :strict)
+      rescue Oj::Error, TypeError, EncodingError => e
+        raise SerializerError, e.message
+      end
+
+      # Alias for dump for JSON gem compatibility
+      #
+      # @param obj [Object] Ruby object to serialize
+      # @return [String] JSON string
+      def generate(obj)
+        Oj.dump(obj, mode: :strict)
+      rescue Oj::Error, TypeError, EncodingError => e
+        raise SerializerError, e.message
+      end
+
+      # Serialize Ruby object to pretty-formatted JSON string
+      #
+      # @param obj [Object] Ruby object to serialize
+      # @return [String] pretty-formatted JSON string
+      def pretty_generate(obj)
+        Oj.dump(obj, mode: :strict, indent: 2)
+      rescue Oj::Error, TypeError, EncodingError => e
+        raise SerializerError, e.message
+      end
+    end
+  end
+end

data/lib/familia/logging.rb

@@ -17,7 +17,7 @@ module Familia
 
     # Get the severity letter from the thread local variable or use
     # the default. The thread local variable is set in the trace
-    # method in the LoggerTraceRefinement module. The name of the
+    # method in the Familia::Refinements::LoggerTrace module. The name of the
     # variable `severity_letter` is arbitrary and could be anything.
     severity_letter = Thread.current[:severity_letter] || severity_letter
 
@@ -36,7 +36,7 @@ module Familia
   # == Methods:
   # trace::
   #   Logs a message at the TRACE level. This method is only available if the
-  #   LoggerTraceRefinement is used.
+  #   Familia::Refinements::LoggerTrace is used.
   #
   # debug::
   #   Logs a message at the DEBUG level. This is used for low-level system information
@@ -59,14 +59,14 @@ module Familia
   #   that will presumably lead the application to abort.
   #
   # == Usage:
-  # To use the Logging module, you need to include the LoggerTraceRefinement module
+  # To use the Logging module, you need to include the Familia::Refinements::LoggerTrace module
   # and use the `using` keyword to enable the refinement. This will add the TRACE
   # log level and the trace method to the Logger class.
   #
   # Example:
   #   require 'logger'
   #
-  #   module LoggerTraceRefinement
+  #   module Familia::Refinements::LoggerTrace
   #     refine Logger do
   #       TRACE = 0
   #
@@ -76,7 +76,7 @@ module Familia
   #     end
   #   end
   #
-  #   using LoggerTraceRefinement
+  #   using Familia::Refinements::LoggerTrace
   #
   #   logger = Logger.new(STDOUT)
   #   logger.trace("This is a trace message")
@@ -86,13 +86,13 @@ module Familia
   #   logger.error("This is an error message")
   #   logger.fatal("This is a fatal message")
   #
-  # In this example, the LoggerTraceRefinement module is defined with a refinement
+  # In this example, the Familia::Refinements::LoggerTrace module is defined with a refinement
   # for the Logger class. The TRACE constant and trace method are added to the Logger
   # class within the refinement. The `using` keyword is used to apply the refinement
   # in the scope where it's needed.
   #
   # == Conditions:
-  # The trace method and TRACE log level are only available if the LoggerTraceRefinement
+  # The trace method and TRACE log level are only available if the Familia::Refinements::LoggerTrace
   # module is used with the `using` keyword. Without this, the Logger class will not
   # have the trace method or the TRACE log level.
   #
@@ -103,7 +103,9 @@ module Familia
     attr_reader :logger
 
     # Gives our logger the ability to use our trace method.
-    using LoggerTraceRefinement if LoggerTraceRefinement::ENABLED
+    if Familia::Refinements::LoggerTrace::ENABLED
+      using Familia::Refinements::LoggerTrace
+    end
 
     def info(*msg)
       @logger.info(*msg)
@@ -140,13 +142,13 @@ module Familia
     #
     # @return [nil]
     #
-    # @note This method only executes if LoggerTraceRefinement::ENABLED is true.
+    # @note This method only executes if Familia::Refinements::LoggerTrace::ENABLED is true.
     # @note The dbclient can be a Database object, Redis::Future (used in
     #   pipelined and multi blocks), or nil (when the database connection isn't
     #   relevant).
     #
     def trace(label, dbclient, ident, context = nil)
-      return unless LoggerTraceRefinement::ENABLED
+      return unless Familia::Refinements::LoggerTrace::ENABLED
 
       # Usually dbclient is a Database object, but it could be
       # a Redis::Future which is what is used inside of pipelined

data/lib/familia/refinements/logger_trace.rb

@@ -0,0 +1,57 @@
+# lib/familia/refinements/logger_trace.rb
+
+require 'pathname'
+require 'logger'
+
+# Controls whether tracing is enabled via an environment variable
+FAMILIA_TRACE = ENV.fetch('FAMILIA_TRACE', 'false').downcase
+
+# Familia::Refinements::LoggerTrace
+#
+# This module adds a 'trace' log level to the Ruby Logger class.
+# It is enabled when the FAMILIA_TRACE environment variable is set to
+# '1', 'true', or 'yes' (case-insensitive).
+#
+# @example Enabling trace logging
+#   # Set environment variable
+#   ENV['FAMILIA_TRACE'] = 'true'
+#
+#   # In your Ruby code
+#   require 'logger'
+#   using Familia::Refinements::LoggerTrace
+#
+#   logger = Logger.new(STDOUT)
+#   logger.trace("This is a trace message")
+#
+module Familia
+  module Refinements
+
+    # Familia::Refinements::LoggerTrace
+    module LoggerTrace
+      unless defined?(ENABLED)
+        # Indicates whether trace logging is enabled
+        ENABLED = %w[1 true yes].include?(FAMILIA_TRACE).freeze
+        # The numeric level for trace logging (same as DEBUG)
+        TRACE = 0
+      end
+
+      refine Logger do
+        ##
+        # Logs a message at the TRACE level.
+        #
+        # @param progname [String] The program name to include in the log message
+        # @yield A block that evaluates to the message to log
+        # @return [true] Always returns true
+        #
+        # @example Logging a trace message
+        #   logger.trace("MyApp") { "Detailed trace information" }
+        def trace(progname = nil, &block)
+          Thread.current[:severity_letter] = 'T'
+          add(Familia::Refinements::LoggerTrace::TRACE, nil, progname, &block)
+        ensure
+          Thread.current[:severity_letter] = nil
+        end
+      end
+    end
+  end
+end

data/lib/familia/refinements/snake_case.rb

@@ -0,0 +1,40 @@
+# lib/familia/refinements/snake_case.rb
+
+module Familia
+  module Refinements
+    module SnakeCase
+      # We refine String rather than Class or Module because this method operates on
+      # string representations of class names (like those from `Class#name`) rather
+      # than the class objects themselves. Refining String is safer because it
+      # limits its scope to only the subset string manipulation contexts where it is
+      # used.
+      #
+      # Appropriate for converting Ruby class names to database table names, config
+      # keys, part of a path or any other snake_case identifiers. The only situation
+      # it is not appropriate for is investigating actual snakes.
+      refine String do
+        # Converts a string from PascalCase/camelCase to snake_case format.
+        #
+        # @return [String] the snake_case version of the string
+        #
+        # @example Converting simple CamelCase
+        #   "FirstName".snake_case #=> "first_name"
+        #
+        # @example Converting PascalCase with acronyms
+        #   XMLHttpRequest.name.snake_case #=> "xml_http_request"
+        #
+        # @example Converting namespaced class names
+        #   "MyApp::UserAccount".snake_case #=> "user_account"
+        #
+        # @example Handling mixed case with numbers
+        #   "parseHTML5Document".snake_case #=> "parse_html5_document"
+        def snake_case
+          split('::').last
+                     .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                     .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                     .downcase
+        end
+      end
+    end
+  end
+end

data/lib/familia/refinements/time_utils.rb

@@ -0,0 +1,248 @@
+# lib/familia/refinements/time_utils.rb
+
+module Familia
+  module Refinements
+
+    # Familia::Refinements::TimeUtils
+    module TimeUtils
+      # Time unit constants
+      PER_MICROSECOND = 0.000001
+      PER_MILLISECOND = 0.001
+      PER_MINUTE      = 60.0
+      PER_HOUR        = 3600.0
+      PER_DAY         = 86_400.0
+      PER_WEEK        = 604_800.0
+      PER_YEAR        = 31_556_952.0 # 365.2425 days (Gregorian year)
+      PER_MONTH       = PER_YEAR / 12.0 # 30.437 days (consistent with Gregorian year)
+
+      UNIT_METHODS = {
+        'y' => :years,
+        'year' => :years,
+        'years' => :years,
+        'mo' => :months,
+        'month' => :months,
+        'months' => :months,
+        'w' => :weeks,
+        'week' => :weeks,
+        'weeks' => :weeks,
+        'd' => :days,
+        'day' => :days,
+        'days' => :days,
+        'h' => :hours,
+        'hour' => :hours,
+        'hours' => :hours,
+        'm' => :minutes,
+        'minute' => :minutes,
+        'minutes' => :minutes,
+        'ms' => :milliseconds,
+        'millisecond' => :milliseconds,
+        'milliseconds' => :milliseconds,
+        'us' => :microseconds,
+        'microsecond' => :microseconds,
+        'microseconds' => :microseconds,
+        'μs' => :microseconds,
+      }.freeze
+
+      refine Numeric do
+        def microseconds = seconds * PER_MICROSECOND
+        def milliseconds = seconds * PER_MILLISECOND
+        def seconds      = self
+        def minutes      = seconds * PER_MINUTE
+        def hours        = seconds * PER_HOUR
+        def days         = seconds * PER_DAY
+        def weeks        = seconds * PER_WEEK
+        def months       = seconds * PER_MONTH
+        def years        = seconds * PER_YEAR
+
+        # Aliases with singular forms
+        alias_method :microsecond, :microseconds
+        alias_method :millisecond, :milliseconds
+        alias_method :second,      :seconds
+        alias_method :minute,      :minutes
+        alias_method :hour,        :hours
+        alias_method :day,         :days
+        alias_method :week,        :weeks
+        alias_method :month,       :months
+        alias_method :year,        :years
+
+        # Fun aliases
+        alias_method :ms, :milliseconds
+        alias_method :μs, :microseconds
+
+        # Seconds -> other time units
+        def in_years        = seconds / PER_YEAR
+        def in_months       = seconds / PER_MONTH
+        def in_weeks        = seconds / PER_WEEK
+        def in_days         = seconds / PER_DAY
+        def in_hours        = seconds / PER_HOUR
+        def in_minutes      = seconds / PER_MINUTE
+        def in_milliseconds = seconds / PER_MILLISECOND
+        def in_microseconds = seconds / PER_MICROSECOND
+        # For semantic purposes
+        def in_seconds      = seconds
+
+        # Time manipulation
+        def ago         = Time.now.utc - seconds
+        def from_now    = Time.now.utc + seconds
+        def before(time) = time - seconds
+        def after(time)  = time + seconds
+        def in_time = Time.at(seconds).utc
+
+        # Milliseconds conversion
+        def to_ms = seconds * 1000.0
+
+        # Converts seconds to specified time unit
+        #
+        # @param u [String, Symbol] Unit to convert to
+        # @return [Float] Converted time value
+        def in_seconds(u = nil)
+          return self unless u
+
+          case UNIT_METHODS.fetch(u.to_s.downcase, nil)
+          when :milliseconds then self * PER_MILLISECOND
+          when :microseconds then self * PER_MICROSECOND
+          when :minutes then self * PER_MINUTE
+          when :hours then self * PER_HOUR
+          when :days then self * PER_DAY
+          when :weeks then self * PER_WEEK
+          when :months then self * PER_MONTH
+          when :years then self * PER_YEAR
+          else self
+          end
+        end
+
+        # Converts the number to a human-readable string representation
+        #
+        # @return [String] A formatted string e.g. "1 day" or "10 seconds"
+        #
+        # @example
+        #   10.to_humanize #=> "10 seconds"
+        #   60.to_humanize #=> "1 minute"
+        #   3600.to_humanize #=> "1 hour"
+        #   86400.to_humanize #=> "1 day"
+        def humanize
+          gte_zero = positive? || zero?
+          duration = (gte_zero ? self : abs) # let's keep it positive up in here
+          text = case (s = duration.to_i)
+                in 0..59 then "#{s} second#{'s' if s != 1}"
+                in 60..3599 then "#{s /= 60} minute#{'s' if s != 1}"
+                in 3600..86_399 then "#{s /= 3600} hour#{'s' if s != 1}"
+                else "#{s /= 86_400} day#{'s' if s != 1}"
+                end
+          gte_zero ? text : "#{text} ago"
+        end
+
+        # Converts the number to a human-readable byte representation using binary units
+        #
+        # @return [String] A formatted string of bytes, KiB, MiB, GiB, or TiB
+        #
+        # @example
+        #   1024.to_bytes      #=> "1.00 KiB"
+        #   2_097_152.to_bytes #=> "2.00 MiB"
+        #   3_221_225_472.to_bytes #=> "3.00 GiB"
+        #
+        def to_bytes
+          units = %w[B KiB MiB GiB TiB]
+          size  = abs.to_f
+          unit  = 0
+
+          while size >= 1024 && unit < units.length - 1
+            size /= 1024
+            unit += 1
+          end
+
+          format('%3.2f %s', size, units[unit])
+        end
+
+        # Calculates age of timestamp in specified unit from reference time
+        #
+        # @param unit [String, Symbol] Time unit ('days', 'hours', 'minutes', 'weeks')
+        # @param from_time [Time, nil] Reference time (defaults to Time.now.utc)
+        # @return [Float] Age in specified unit
+        # @example
+        #   timestamp = 2.days.ago.to_i
+        #   timestamp.age_in(:days)         #=> ~2.0
+        #   timestamp.age_in('hours')       #=> ~48.0
+        #   timestamp.age_in(:days, 1.day.ago) #=> ~1.0
+        def age_in(unit, from_time = nil)
+          from_time ||= Time.now.utc
+          age_seconds = from_time.to_f - to_f
+          case UNIT_METHODS.fetch(unit.to_s.downcase, nil)
+          when :days then age_seconds / PER_DAY
+          when :hours then age_seconds / PER_HOUR
+          when :minutes then age_seconds / PER_MINUTE
+          when :weeks then age_seconds / PER_WEEK
+          when :months then age_seconds / PER_MONTH
+          when :years then age_seconds / PER_YEAR
+          else age_seconds
+          end
+        end
+
+        # Convenience methods for `age_in(unit)` calls.
+        #
+        # @param from_time [Time, nil] Reference time (defaults to Time.now.utc)
+        # @return [Float] Age in days
+        # @example
+        #   timestamp.days_old    #=> 2.5
+        def days_old(*) = age_in(:days, *)
+        def hours_old(*) = age_in(:hours, *)
+        def minutes_old(*) = age_in(:minutes, *)
+        def weeks_old(*) = age_in(:weeks, *)
+        def months_old(*) = age_in(:months, *)
+        def years_old(*) = age_in(:years, *)
+
+        # Checks if timestamp is older than specified duration in seconds
+        #
+        # @param duration [Numeric] Duration in seconds to compare against
+        # @return [Boolean] true if timestamp is older than duration
+        # @note Both older_than? and newer_than? can return false when timestamp
+        #   is within the same second. Use within? to check this case.
+        #
+        # @example
+        #   Time.now.older_than?(1.second)    #=> false
+        def older_than?(duration)
+          self < (Time.now.utc.to_f - duration)
+        end
+
+        # Checks if timestamp is newer than specified duration in the future
+        #
+        # @example
+        #   Time.now.newer_than?(1.second)    #=> false
+        def newer_than?(duration)
+          self > (Time.now.utc.to_f + duration)
+        end
+
+        # Checks if timestamp is within specified duration of now (past or future)
+        #
+        # @param duration [Numeric] Duration in seconds to compare against
+        # @return [Boolean] true if timestamp is within duration of now
+        # @example
+        #   30.minutes.ago.to_i.within?(1.hour)     #=> true
+        #   30.minutes.from_now.to_i.within?(1.hour) #=> true
+        #   2.hours.ago.to_i.within?(1.hour)        #=> false
+        def within?(duration)
+          (self - Time.now.utc.to_f).abs <= duration
+        end
+      end
+
+      refine ::String do
+        # Converts string time representation to seconds
+        #
+        # @example
+        #   "60m".in_seconds #=> 3600.0
+        #   "2.5h".in_seconds #=> 9000.0
+        #   "1y".in_seconds #=> 31536000.0
+        #
+        # @return [Float, nil] Time in seconds or nil if invalid
+        def in_seconds
+          q, u = scan(/([\d.]+)([a-zA-Zμs]+)?/).flatten
+          return nil unless q
+
+          q   = q.to_f
+          u ||= 's'
+          q.in_seconds(u)
+        end
+      end
+    end
+  end
+end

data/lib/familia/refinements.rb

@@ -1,51 +1,5 @@
 # lib/familia/refinements.rb
 
-require 'pathname'
-require 'logger'
-
-# Controls whether tracing is enabled via an environment variable
-FAMILIA_TRACE = ENV.fetch('FAMILIA_TRACE', 'false').downcase
-
-# LoggerTraceRefinement
-#
-# This module adds a 'trace' log level to the Ruby Logger class.
-# It is enabled when the FAMILIA_TRACE environment variable is set to
-# '1', 'true', or 'yes' (case-insensitive).
-#
-# @example Enabling trace logging
-#   # Set environment variable
-#   ENV['FAMILIA_TRACE'] = 'true'
-#
-#   # In your Ruby code
-#   require 'logger'
-#   using LoggerTraceRefinement
-#
-#   logger = Logger.new(STDOUT)
-#   logger.trace("This is a trace message")
-#
-module LoggerTraceRefinement
-  unless defined?(ENABLED)
-    # Indicates whether trace logging is enabled
-    ENABLED = %w[1 true yes].include?(FAMILIA_TRACE).freeze
-    # The numeric level for trace logging (same as DEBUG)
-    TRACE = 0
-  end
-
-  refine Logger do
-    ##
-    # Logs a message at the TRACE level.
-    #
-    # @param progname [String] The program name to include in the log message
-    # @yield A block that evaluates to the message to log
-    # @return [true] Always returns true
-    #
-    # @example Logging a trace message
-    #   logger.trace("MyApp") { "Detailed trace information" }
-    def trace(progname = nil, &block)
-      Thread.current[:severity_letter] = 'T'
-      add(LoggerTraceRefinement::TRACE, nil, progname, &block)
-    ensure
-      Thread.current[:severity_letter] = nil
-    end
-  end
-end
+require_relative 'refinements/logger_trace'
+require_relative 'refinements/snake_case'
+require_relative 'refinements/time_utils'