callback_tracer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dc2f5bb8dbc7993f062b1a9278293e8927e3003b57ffd8393679e1fa378184e2
+  data.tar.gz: 12b226db470343333e74512e8c29ca39437eccdc75821ecd2516b1747a32bf83
+SHA512:
+  metadata.gz: 8758991c2da82f688267e8b0bda7f029be6a74171aaa7b9d8050abd8b9e8dd7008669d40d5d81edabf866330f2844062ed9b25a76e210b61f3653d67137ccf95
+  data.tar.gz: fcfb5d5b1202b7183654a1d111c533ce7bd7a03b8a8bc968870051aca8965dfb183bbe880bcefee710e7eb63438cd554c65af6f0f20fb0af4fc9b9bd5c26d018

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0 (2026-03-24)
+
+- Initial release
+- Trace all ActiveRecord callback chains (validation, save, create, update, destroy, commit, rollback, initialize, find, touch)
+- Source location and timing for each callback
+- Around callback enter/exit tracing
+- Colorized terminal output
+- Configurable: enable/disable, exclude models, custom logger
+- Rails generator for initializer setup
+- Automatic production safety (disabled in production)
+- Rack middleware for per-request buffer flushing

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Shehab Mohamed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,48 @@
+# CallbackTracer
+
+Trace ActiveRecord callback execution order with source locations and timing. See exactly which callbacks fire, in what order, and how long each takes.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "callback_tracer", group: [:development, :test]
+```
+
+Run the install generator:
+
+```bash
+rails generate callback_tracer:install
+```
+
+## Configuration
+
+```ruby
+# config/initializers/callback_tracer.rb
+CallbackTracer.configure do |config|
+  config.enabled = true
+  config.excluded_models = ["ApplicationRecord"]
+  config.colorize = true
+  config.logger = nil # defaults to puts
+end
+```
+
+## Output
+
+```
+[CallbackTracer] Post before_validation (app/models/post.rb:11) 0.02ms
+[CallbackTracer] Post after_validation  (app/models/post.rb:12) 0.01ms
+[CallbackTracer] Post before_save       (app/models/post.rb:16) 0.03ms
+[CallbackTracer] Post before_create     (app/models/post.rb:21) 0.15ms
+[CallbackTracer] Post after_create      (app/models/post.rb:23) 0.02ms
+[CallbackTracer] Post after_save        (app/models/post.rb:18) 0.01ms
+[CallbackTracer] Post after_commit      (app/models/post.rb:31) 0.04ms
+```
+
+## Requirements
+
+- Ruby 3.1+
+- Rails 7.0+
+
+Automatically disabled in production.

data/lib/callback_tracer/configuration.rb

@@ -0,0 +1,44 @@
+module CallbackTracer
+  class Configuration
+    attr_reader :enabled, :excluded_models, :colorize, :logger
+
+    def initialize
+      @enabled = false
+      @excluded_models = []
+      @colorize = true
+      @logger = nil
+    end
+
+    def enabled=(value)
+      @enabled = !!value
+    end
+
+    def colorize=(value)
+      @colorize = !!value
+    end
+
+    def excluded_models=(value)
+      raise ArgumentError, "excluded_models must be an Array" unless value.is_a?(Array)
+
+      @excluded_models = value
+    end
+
+    def logger=(value)
+      if value && !value.respond_to?(:info)
+        raise ArgumentError, "logger must respond to #info"
+      end
+
+      @logger = value
+    end
+
+    def excluded?(model_class)
+      model_name = model_class.name
+      return false unless model_name
+
+      excluded_models.any? do |name|
+        model_name == name ||
+          model_class.ancestors.any? { |a| a.name == name && name != "ActiveRecord::Base" }
+      end
+    end
+  end
+end

data/lib/callback_tracer/log_formatter.rb

@@ -0,0 +1,78 @@
+module CallbackTracer
+  module LogFormatter
+    COLORS = {
+      prefix:   "\e[36m",   # cyan
+      model:    "\e[33m",   # yellow
+      callback: "\e[32m",   # green
+      location: "\e[90m",   # gray
+      timing:   "\e[35m",   # magenta
+      around:   "\e[34m",   # blue
+      reset:    "\e[0m"
+    }.freeze
+
+    # Control characters that could be used for log injection or terminal escape attacks
+    CONTROL_CHAR_PATTERN = /[\r\n\e\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/
+
+    module_function
+
+    def sanitize(str)
+      str.to_s.gsub(CONTROL_CHAR_PATTERN, "")
+    end
+
+    def format_callback(model_name:, callback_kind:, callback_type:, location:, duration_ms:, method_name: nil, colorize: true)
+      model_name = sanitize(model_name)
+      kind_label = sanitize("#{callback_type}_#{callback_kind}")
+      kind_label = "#{kind_label} :#{method_name}" if method_name
+      loc_str = location ? "(#{sanitize(location)})" : "(unknown)"
+      time_str = "%.2fms" % duration_ms
+
+      if colorize
+        "#{c(:prefix)}[CallbackTracer]#{c(:reset)} " \
+        "#{c(:model)}#{model_name}#{c(:reset)} " \
+        "#{c(:callback)}#{kind_label.ljust(25)}#{c(:reset)} " \
+        "#{c(:location)}#{loc_str}#{c(:reset)} " \
+        "#{c(:timing)}#{time_str}#{c(:reset)}"
+      else
+        "[CallbackTracer] #{model_name} #{kind_label.ljust(25)} #{loc_str} #{time_str}"
+      end
+    end
+
+    def format_around_enter(model_name:, callback_kind:, location:, method_name: nil, colorize: true)
+      model_name = sanitize(model_name)
+      loc_str = location ? "(#{sanitize(location)})" : "(unknown)"
+      label = sanitize("around_#{callback_kind} [enter]")
+      label = "#{label} :#{method_name}" if method_name
+
+      if colorize
+        "#{c(:prefix)}[CallbackTracer]#{c(:reset)} " \
+        "#{c(:model)}#{model_name}#{c(:reset)} " \
+        "#{c(:around)}#{label.ljust(25)}#{c(:reset)} " \
+        "#{c(:location)}#{loc_str}#{c(:reset)}"
+      else
+        "[CallbackTracer] #{model_name} #{label.ljust(25)} #{loc_str}"
+      end
+    end
+
+    def format_around_exit(model_name:, callback_kind:, location:, duration_ms:, method_name: nil, colorize: true)
+      model_name = sanitize(model_name)
+      loc_str = location ? "(#{sanitize(location)})" : "(unknown)"
+      time_str = "%.2fms" % duration_ms
+      label = sanitize("around_#{callback_kind} [exit]")
+      label = "#{label} :#{method_name}" if method_name
+
+      if colorize
+        "#{c(:prefix)}[CallbackTracer]#{c(:reset)} " \
+        "#{c(:model)}#{model_name}#{c(:reset)} " \
+        "#{c(:around)}#{label.ljust(25)}#{c(:reset)} " \
+        "#{c(:location)}#{loc_str}#{c(:reset)} " \
+        "#{c(:timing)}#{time_str}#{c(:reset)}"
+      else
+        "[CallbackTracer] #{model_name} #{label.ljust(25)} #{loc_str} #{time_str}"
+      end
+    end
+
+    def c(name)
+      COLORS[name]
+    end
+  end
+end

data/lib/callback_tracer/middleware.rb

@@ -0,0 +1,15 @@
+module CallbackTracer
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      CallbackTracer.clear_buffer!
+      response = @app.call(env)
+      response
+    ensure
+      CallbackTracer.flush_buffer!
+    end
+  end
+end

data/lib/callback_tracer/railtie.rb

@@ -0,0 +1,13 @@
+module CallbackTracer
+  class Railtie < Rails::Railtie
+    initializer "callback_tracer.setup" do
+      ActiveSupport.on_load(:active_record) do
+        CallbackTracer.setup! unless Rails.env.production?
+      end
+    end
+
+    initializer "callback_tracer.middleware" do |app|
+      app.middleware.use CallbackTracer::Middleware unless Rails.env.production?
+    end
+  end
+end

data/lib/callback_tracer/source_locator.rb

@@ -0,0 +1,59 @@
+module CallbackTracer
+  module SourceLocator
+    module_function
+
+    def locate(filter, model_class)
+      location = extract_location(filter, model_class)
+      return nil unless location
+
+      file, line = location
+      shorten_path(file, line)
+    end
+
+    def extract_location(filter, model_class)
+      case filter
+      when Symbol
+        if model_class.method_defined?(filter, false) || model_class.private_method_defined?(filter, false)
+          model_class.instance_method(filter).source_location
+        elsif model_class.method_defined?(filter) || model_class.private_method_defined?(filter)
+          model_class.instance_method(filter).source_location
+        end
+      when Proc
+        filter.source_location
+      when Object
+        # Callable object — try common callback method names
+        [:before, :after, :around, :call].each do |m|
+          return filter.method(m).source_location if filter.respond_to?(m)
+        end
+        nil
+      end
+    rescue NameError, TypeError
+      nil
+    end
+
+    # Matches bundled gem paths like /gems/activerecord-7.1.0/ or /gems/railties-7.1.0/
+    BUNDLED_GEM_PATH_PATTERN = %r{/gems/[a-zA-Z0-9_-]+-\d+}
+
+    def framework_source?(filter, model_class)
+      location = extract_location(filter, model_class)
+      return false unless location
+
+      file = location[0].to_s
+      return true if file.match?(BUNDLED_GEM_PATH_PATTERN)
+      return true if defined?(Rails) && Rails.respond_to?(:root) && Rails.root && !file.start_with?(Rails.root.to_s)
+
+      false
+    end
+
+    def shorten_path(file, line)
+      shortened = if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+                    file.sub("#{Rails.root}/", "")
+                  elsif defined?(Bundler) && Bundler.respond_to?(:root)
+                    file.sub("#{Bundler.root}/", "")
+                  else
+                    File.basename(File.dirname(file)) + "/" + File.basename(file)
+                  end
+      "#{shortened}:#{line}"
+    end
+  end
+end

data/lib/callback_tracer/tracer.rb

@@ -0,0 +1,218 @@
+require "logger"
+require "monitor"
+
+module CallbackTracer
+  module Tracer
+    TRACED_KINDS = %i[
+      validation save create update destroy
+      commit rollback initialize find touch
+    ].freeze
+
+    TRACE_MONITOR = Monitor.new
+
+    def run_callbacks(kind, &block)
+      unless CallbackTracer.enabled? &&
+             TRACED_KINDS.include?(kind) &&
+             !CallbackTracer.configuration.excluded?(self.class)
+        return super
+      end
+
+      callbacks = self.class.__callbacks[kind]
+      return super unless callbacks
+
+      chain = callbacks.send(:chain).dup
+      colorize = CallbackTracer.configuration.colorize
+      model_name = LogFormatter.sanitize(self.class.name.to_s)
+      logger = CallbackTracer.configuration.logger
+
+      # Build wrappers for each callback in the chain, skipping framework-internal ones
+      wrappers = chain.filter_map do |cb|
+        filter = cb.filter
+        next if SourceLocator.framework_source?(filter, self.class)
+
+        location = SourceLocator.locate(filter, self.class)
+        cb_kind = cb.kind # :before, :after, :around
+        method_name = filter.is_a?(Symbol) ? filter : nil
+
+        { callback: cb, filter: filter, location: location, cb_kind: cb_kind, method_name: method_name }
+      end
+
+      # Install temporary method wrappers to trace individual callbacks
+      install_method_wrappers(wrappers, model_name, kind, colorize, logger)
+
+      # For proc filters, wrap them thread-safely without mutating shared state
+      trace_proc_filters(wrappers, model_name, kind, colorize, logger) do
+        super(kind, &block)
+      end
+    end
+
+    private
+
+    def install_method_wrappers(wrappers, model_name, callback_kind, colorize, logger)
+      # Track which methods we've already wrapped on this instance to avoid accumulation
+      @_callback_tracer_wrapped ||= Set.new
+
+      wrappers.each do |w|
+        filter = w[:filter]
+        next unless filter.is_a?(Symbol)
+        next if @_callback_tracer_wrapped.include?(filter)
+        next unless self.class.method_defined?(filter, false) || self.class.private_method_defined?(filter, false)
+
+        location = w[:location]
+        cb_kind = w[:cb_kind]
+        method_name = w[:method_name]
+
+        wrapper_module = Module.new do
+          if cb_kind == :around
+            define_method(filter) do |*args, &blk|
+              output_enter = LogFormatter.format_around_enter(
+                model_name: model_name,
+                callback_kind: callback_kind,
+                location: location,
+                method_name: method_name,
+                colorize: colorize
+              )
+              log_trace(output_enter, logger)
+
+              start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              result = super(*args, &blk)
+              duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+
+              output_exit = LogFormatter.format_around_exit(
+                model_name: model_name,
+                callback_kind: callback_kind,
+                location: location,
+                method_name: method_name,
+                duration_ms: duration,
+                colorize: colorize
+              )
+              log_trace(output_exit, logger)
+              result
+            end
+          else
+            define_method(filter) do |*args, &blk|
+              start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              result = super(*args, &blk)
+              duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+
+              output = LogFormatter.format_callback(
+                model_name: model_name,
+                callback_kind: callback_kind,
+                callback_type: cb_kind,
+                location: location,
+                method_name: method_name,
+                duration_ms: duration,
+                colorize: colorize
+              )
+              log_trace(output, logger)
+              result
+            end
+          end
+        end
+
+        self.singleton_class.prepend(wrapper_module)
+        @_callback_tracer_wrapped.add(filter)
+      end
+    end
+
+    def trace_proc_filters(wrappers, model_name, callback_kind, colorize, logger)
+      proc_wrappers = wrappers.select { |w| w[:filter].is_a?(Proc) }
+
+      if proc_wrappers.empty?
+        return yield
+      end
+
+      # Thread-safe approach: duplicate the callback objects before mutating,
+      # then swap the entire chain under a mutex so no shared state is modified.
+      callbacks_set = self.class.__callbacks[callback_kind]
+      original_chain = callbacks_set.send(:chain)
+
+      # Deep-copy the callback objects we need to wrap
+      cloned_cbs = {}
+      proc_wrappers.each do |w|
+        cb = w[:callback]
+        cloned = cb.dup
+        cloned_cbs[cb.object_id] = { original: cb, clone: cloned }
+      end
+
+      # Build wrapped procs on the cloned copies (no shared state mutation)
+      cloned_cbs.each_value do |entry|
+        cloned_cb = entry[:clone]
+        w = proc_wrappers.find { |pw| pw[:callback].object_id == entry[:original].object_id }
+        filter = w[:filter]
+        location = w[:location]
+        cb_kind = w[:cb_kind]
+
+        wrapped_proc = build_wrapped_proc(filter, cb_kind, model_name, callback_kind, location, colorize, logger)
+        cloned_cb.instance_variable_set(:@filter, wrapped_proc)
+      end
+
+      # Hold mutex for the entire swap-yield-restore cycle to prevent
+      # TOCTOU race conditions between concurrent threads.
+      TRACE_MONITOR.synchronize do
+        cloned_cbs.each_value do |entry|
+          idx = original_chain.index(entry[:original])
+          original_chain[idx] = entry[:clone] if idx
+        end
+
+        begin
+          yield
+        ensure
+          cloned_cbs.each_value do |entry|
+            idx = original_chain.index(entry[:clone])
+            original_chain[idx] = entry[:original] if idx
+          end
+        end
+      end
+    end
+
+    def build_wrapped_proc(filter, cb_kind, model_name, callback_kind, location, colorize, logger)
+      if cb_kind == :around
+        proc do |record, &blk|
+          output_enter = LogFormatter.format_around_enter(
+            model_name: model_name,
+            callback_kind: callback_kind,
+            location: location,
+            colorize: colorize
+          )
+          record.send(:log_trace, output_enter, logger)
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result = filter.call(record, &blk)
+          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+
+          output_exit = LogFormatter.format_around_exit(
+            model_name: model_name,
+            callback_kind: callback_kind,
+            location: location,
+            duration_ms: duration,
+            colorize: colorize
+          )
+          record.send(:log_trace, output_exit, logger)
+          result
+        end
+      else
+        proc do |record, &blk|
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          result = record.instance_exec(&filter)
+          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+
+          output = LogFormatter.format_callback(
+            model_name: model_name,
+            callback_kind: callback_kind,
+            callback_type: cb_kind,
+            location: location,
+            duration_ms: duration,
+            colorize: colorize
+          )
+          record.send(:log_trace, output, logger)
+          result
+        end
+      end
+    end
+
+    def log_trace(message, _logger = nil)
+      CallbackTracer.buffer_message(message)
+    end
+  end
+end

data/lib/callback_tracer/version.rb

@@ -0,0 +1,3 @@
+module CallbackTracer
+  VERSION = "0.1.0"
+end

data/lib/callback_tracer.rb

@@ -0,0 +1,72 @@
+require "active_support"
+require "active_record"
+
+require_relative "callback_tracer/version"
+require_relative "callback_tracer/configuration"
+require_relative "callback_tracer/source_locator"
+require_relative "callback_tracer/log_formatter"
+require_relative "callback_tracer/tracer"
+require_relative "callback_tracer/middleware"
+require_relative "callback_tracer/railtie" if defined?(Rails::Railtie)
+
+module CallbackTracer
+  SETUP_MUTEX = Mutex.new
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def setup!
+      SETUP_MUTEX.synchronize do
+        return if @setup_done
+
+        if defined?(Rails) && Rails.respond_to?(:env) && Rails.env.production?
+          warn "[CallbackTracer] WARNING: CallbackTracer.setup! called in production. Tracing is disabled in production by default."
+          return
+        end
+
+        ActiveRecord::Base.prepend(Tracer)
+        @setup_done = true
+      end
+    end
+
+    def reset!
+      SETUP_MUTEX.synchronize do
+        @configuration = Configuration.new
+        @setup_done = false
+      end
+    end
+
+    def enabled?
+      configuration.enabled
+    end
+
+    def buffer
+      Thread.current[:callback_tracer_buffer] ||= []
+    end
+
+    def buffer_message(message)
+      buffer << message
+    end
+
+    def clear_buffer!
+      Thread.current[:callback_tracer_buffer] = []
+    end
+
+    def flush_buffer!
+      messages = buffer
+      return if messages.empty?
+
+      logger = configuration.logger
+      output_logger = logger || Logger.new($stdout, formatter: proc { |_, _, _, msg| "#{msg}\n" })
+      messages.each { |msg| output_logger.info(msg) }
+    ensure
+      clear_buffer!
+    end
+  end
+end

data/lib/generators/callback_tracer/install_generator.rb

@@ -0,0 +1,27 @@
+require "rails/generators"
+
+module CallbackTracer
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Creates a CallbackTracer initializer file"
+
+      def create_initializer
+        create_file "config/initializers/callback_tracer.rb", <<~RUBY
+          CallbackTracer.configure do |config|
+            # Enable or disable tracing (automatically disabled in production)
+            # config.enabled = true
+
+            # Models to exclude from tracing
+            # config.excluded_models = ["ApplicationRecord", "ActiveRecord::SchemaMigration"]
+
+            # Enable colorized output
+            # config.colorize = true
+
+            # Custom logger (defaults to puts)
+            # config.logger = Rails.logger
+          end
+        RUBY
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: callback_tracer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shehab Mohamed
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-03-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: Instruments all ActiveRecord callbacks and prints their execution order,
+  source location, and timing to the terminal during development and test.
+email:
+- shehab.mohamed2104@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/callback_tracer.rb
+- lib/callback_tracer/configuration.rb
+- lib/callback_tracer/log_formatter.rb
+- lib/callback_tracer/middleware.rb
+- lib/callback_tracer/railtie.rb
+- lib/callback_tracer/source_locator.rb
+- lib/callback_tracer/tracer.rb
+- lib/callback_tracer/version.rb
+- lib/generators/callback_tracer/install_generator.rb
+homepage: https://github.com/ShehabMohamed21/callback_tracer_gem
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ShehabMohamed21/callback_tracer_gem
+  source_code_uri: https://github.com/ShehabMohamed21/callback_tracer_gem
+  changelog_uri: https://github.com/ShehabMohamed21/callback_tracer_gem/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Trace ActiveRecord callback execution order with source locations and timing
+test_files: []