rails-profiler 0.34.3 → 0.34.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 066e4af89b9741273fe1740d6dfbcecaa32df311835699642cafad8e703ca4ec
-  data.tar.gz: 05f65764c8e80a2b61ceea1f164dd85fa1d3d920b71452c3abdd35044698107b
+  metadata.gz: 0b498ec1274af5787fe96b70e64613b009298b578a7b084d65d450ec86a431bc
+  data.tar.gz: b575d9afef090eee5539cfca2ffd536887d90b4c08a3b5099504a8e31ca69eab
 SHA512:
-  metadata.gz: 7eeb6e60ace7bbfccb32d3a5eeb0d42243a5bd39d551d08aeaefe05ae8cb79a76b91aee3e1e2a5e2edcaba11d1cd99a89d9860c788841915b16a62483bc457bb
-  data.tar.gz: ae5f198e1f98ca9f964b25a1fba4d419d4c2544e5c651d7921f984626be85d64f4afc494501602e4a19e306ff6cacc8d16f9e5c6f2895a45778af1f444c7e3e3
+  metadata.gz: f7da413fad8fd79420dddc04242b1ce30c05aac1106073219b7c0dcda26dada8c59a1b8e0d6a6c3c403d92ee6cd519271285d5f99fe6670b0e970179f79be119
+  data.tar.gz: d36516568229d7fa228dad51b70a30e8ca2753cc07fa114279f322200d32bd9a4f5e02891ff0ea96b0c904dc1594d528f677129b840fe0acadd2f106f29ea9cc

data/CHANGELOG.md

@@ -19,6 +19,40 @@ every commit of every tag interval is accounted for one way or the other.
 
 ## [Unreleased]
 
+## [0.34.5] - 2026-10-16
+
+<!-- stamped -->
+
+### Fixed
+
+- **Request capture:** the parameters of a request are now read once the application has returned, so
+  route parameters are present and `param_encoding` is applied, and they are converted to UTF-8. They
+  used to be read in the outermost middleware, before the router ran.
+- **Request capture:** a text body keeps its accents. It is now read in the `charset` of its
+  `Content-Type`, UTF-8 when it declares none, and invalid bytes are replaced, instead of every
+  accent being turned into a replacement character.
+- **Request capture:** a request whose `Content-Type` declares a charset Ruby cannot convert from
+  (`charset=utf-7`, `charset=internal`) no longer loses its profile; the body is read as UTF-8 with
+  invalid bytes replaced.
+
+## [0.34.4] - 2026-10-16
+
+<!-- stamped -->
+
+### Fixed
+
+- **Sidekiq:** A job run through the ActiveJob adapter is no longer profiled twice. It reaches the
+  Sidekiq middleware wrapped (`job["wrapped"]`) and is already profiled by the ActiveJob
+  `around_perform` callback, so the middleware now leaves it alone when ActiveJob is instrumented
+  and the same work is recorded once.
+- **Logs:** The log buffer behind `CaptureLogger` is now guarded by a `Mutex`, so lines recorded
+  from several threads at once (a streamed body iterated by another thread, work handed the buffer)
+  keep the byte count and the stored lines consistent.
+- **Flame graph and views:** Nested durations are counted once. The total of the flame graph and
+  the total of the views and partials now cover each moment a single time, so a template that
+  renders partials, or a controller action that runs queries, is no longer added to what it
+  contains.
+
 ## [0.34.3] - 2026-10-15
 
 <!-- stamped -->

data/lib/profiler/collectors/base_collector.rb

@@ -124,6 +124,24 @@ module Profiler
 
       protected
 
+      # The time covered by +intervals+ ([started, finished] pairs of Time or Float seconds), in
+      # milliseconds, each moment counted once: a template that renders partials, or a controller
+      # action that runs queries, is not added to what it contains.
+      def covered_ms(intervals)
+        covered = 0.0
+        current_end = nil
+        intervals.sort_by(&:first).each do |started, finished|
+          if current_end.nil? || started >= current_end
+            covered += finished - started
+            current_end = finished
+          elsif finished > current_end
+            covered += finished - current_end
+            current_end = finished
+          end
+        end
+        (covered * 1000).round(2)
+      end
+
       def store_data(data)
         @data = data
         @profile.add_collector_data(name, data)

data/lib/profiler/collectors/flamegraph_collector.rb

@@ -139,7 +139,7 @@ module Profiler
 
         store_data({
           total_events: @events.size,
-          total_duration: @events.empty? ? 0 : @events.map(&:duration).sum.round(2),
+          total_duration: @events.empty? ? 0 : covered_ms(@events.map { |e| [e.started_at, e.finished_at] }),
           root_events: root_events.map(&:to_h)
         })
       end

data/lib/profiler/collectors/log_collector.rb

@@ -20,13 +20,22 @@ module Profiler
           @bytes = 0
           @dropped = 0
           @truncated = false
+          @mutex = Mutex.new
         end
 
         def truncated?
           @truncated
         end
 
+        # A streamed body iterated by another thread, or work handed the buffer, can record while
+        # the request's own thread does: the byte count and the lines are updated together.
         def record(entry)
+          @mutex.synchronize { record_unlocked(entry) }
+        end
+
+        private
+
+        def record_unlocked(entry)
           message = entry[:message]
           if @limit
             room = @limit - @bytes

data/lib/profiler/collectors/view_collector.rb

@@ -9,6 +9,7 @@ module Profiler
         super
         @views = []
         @partials = []
+        @intervals = []
         @subscriptions = []
       end
 
@@ -36,6 +37,7 @@ module Profiler
 
         @subscriptions << subscribe_notification("render_template.action_view") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
+          @intervals << [started, finished]
           @views << {
             identifier: payload[:identifier],
             layout: payload[:layout],
@@ -45,6 +47,7 @@ module Profiler
 
         @subscriptions << subscribe_notification("render_partial.action_view") do |name, started, finished, unique_id, payload|
           duration = ((finished - started) * 1000).round(2)
+          @intervals << [started, finished]
           @partials << {
             identifier: payload[:identifier],
             duration: duration
@@ -60,7 +63,7 @@ module Profiler
           partials: @partials,
           total_views: @views.size,
           total_partials: @partials.size,
-          total_duration: (@views + @partials).sum { |v| v[:duration] }.round(2)
+          total_duration: covered_ms(@intervals)
         }
 
         store_data(data)
@@ -76,7 +79,7 @@ module Profiler
       end
 
       def toolbar_summary
-        total_duration = (@views + @partials).sum { |v| v[:duration] }.round(2)
+        total_duration = covered_ms(@intervals)
 
         {
           text: "#{@views.size} views, #{@partials.size} partials (#{total_duration}ms)",

data/lib/profiler/instrumentation/sidekiq_middleware.rb

@@ -12,6 +12,11 @@ module Profiler
     class SidekiqMiddleware
       def call(worker, job, queue, &block)
         Profiler.env_override_store.apply!
+        # A job run through the ActiveJob adapter reaches Sidekiq wrapped (job["wrapped"] names the
+        # real class) and is profiled by ActiveJobInstrumentation's around_perform: profiling the
+        # wrapper too would record the same work twice.
+        return block.call if job["wrapped"] && active_job_profiled?
+
         Profiler::JobProfiler.profile(
           job_class: job["class"],
           job_id: job["jid"],
@@ -22,6 +27,13 @@ module Profiler
           &block
         )
       end
+
+      private
+
+      def active_job_profiled?
+        defined?(ActiveJob::Base) && defined?(Profiler::Instrumentation::ActiveJobInstrumentation) &&
+          ActiveJob::Base.include?(Profiler::Instrumentation::ActiveJobInstrumentation)
+      end
     end
   end
 end

data/lib/profiler/middleware/profiler_middleware.rb

@@ -28,7 +28,7 @@ module Profiler
         kept = nil
         begin
           begin
-            profile = Models::Profile.new(build_request(env))
+            profile = Models::Profile.new(build_request(env), params: false)
             profile.gem_version = Profiler::VERSION
             Profiler::CurrentContext.token = profile.token
 
@@ -57,10 +57,12 @@ module Profiler
           begin
             response = @app.call(env)
           rescue Exception => e # rubocop:disable Lint/RescueException
+            capture_params(env, profile) if failed_request?(e)
             record_failed_request(env, profile, collectors, request_body, allocations_before, e) if failed_request?(e)
             raise
           end
 
+          capture_params(env, profile)
           response, kept = complete_profile(env, profile, collectors, request_body, allocations_before, response)
           response
         ensure
@@ -74,6 +76,14 @@ module Profiler
 
       private
 
+      # Read after the application has run, so after the routing: the route parameters are there,
+      # and the params carry the encoding the route declared, as the controller saw them.
+      def capture_params(env, profile)
+        profile.capture_params(build_request(env))
+      rescue => e
+        Profiler.log_error("ProfilerMiddleware: could not read the request params", e)
+      end
+
       def complete_profile(env, profile, collectors, request_body, allocations_before, response)
         status, headers, body = response
 

data/lib/profiler/models/profile.rb

@@ -22,7 +22,9 @@ module Profiler
                     :collectors_released_after_seconds, :params_truncated,
                     :gem_version
 
-      def initialize(request = nil)
+      # +params+: false leaves the params to capture_params, for a caller that builds the profile
+      # before the router has run.
+      def initialize(request = nil, params: true)
         @token = SecureRandom.hex(16)
         @started_at = Time.now
         @collectors_data = {}
@@ -34,12 +36,19 @@ module Profiler
         if request
           @path = request.path
           @method = request.request_method
-          @params, @params_truncated = cap_params(sanitize_params(request.params),
-                                                  Profiler.configuration.max_captured_body_bytes)
+          capture_params(request) if params
           @headers = extract_headers(request.env)
         end
       end
 
+      # The request's params as the controller sees them. Read once the router has run: Rails
+      # adds the route parameters (:id...) and applies the routes' param_encoding only then, so
+      # a read before it keeps neither.
+      def capture_params(request)
+        @params, @params_truncated = cap_params(sanitize_params(utf8_params(request.params)),
+                                                Profiler.configuration.max_captured_body_bytes)
+      end
+
       # The sizes are those of the whole bodies, when a body was cut at max_captured_body_bytes;
       # *_size_is_minimum when the whole size is not known (no Content-Length, a stream that
       # stopped), only that it is at least that.
@@ -252,7 +261,7 @@ module Profiler
           # compressed format (zip, png, gzip...) does not hold the secret as it is.
           { body: Base64.strict_encode64(Redaction.hide_credentials(raw.b)), encoding: "base64" }
         else
-          text = Redaction.filter_body(raw, content_type).encode("UTF-8", invalid: :replace, undef: :replace)
+          text = utf8_text(Redaction.filter_body(raw, content_type), content_type)
           if compress_body?(text)
             # The fastest level: paid on the request, a quarter larger than the default level.
             { body: Base64.strict_encode64(Zlib::Deflate.deflate(text, Zlib::BEST_SPEED)), encoding: "gzip+base64" }
@@ -262,6 +271,39 @@ module Profiler
         end
       end
 
+      # The text as UTF-8: a body read from the wire is binary, and is taken for the charset its
+      # Content-Type declares (UTF-8 when it declares none, or one Ruby does not know). Bytes
+      # that do not belong to it are replaced, never raised on.
+      def utf8_text(text, content_type)
+        return text.encode("UTF-8", invalid: :replace, undef: :replace) unless text.encoding == Encoding::BINARY
+
+        charset = content_type.to_s[/charset\s*=\s*"?([^\s";]+)/i, 1]
+        source = begin
+          charset ? Encoding.find(charset) : Encoding::UTF_8
+        rescue ArgumentError
+          Encoding::UTF_8
+        end
+        # "internal" is a name Ruby knows but resolves to nil, "utf-7" is a dummy encoding with no converter.
+        source ||= Encoding::UTF_8
+        begin
+          text.dup.force_encoding(source).encode("UTF-8", invalid: :replace, undef: :replace)
+        rescue EncodingError
+          text.dup.force_encoding(Encoding::UTF_8).encode("UTF-8", invalid: :replace, undef: :replace)
+        end
+      end
+
+      # The params with their strings in UTF-8: a route's param_encoding gives some another
+      # encoding, which the profile must not carry into its JSON.
+      def utf8_params(value)
+        case value
+        when Hash then value.to_h { |k, v| [utf8_params(k), utf8_params(v)] }
+        when Array then value.map { |v| utf8_params(v) }
+        when String
+          value.encoding == Encoding::UTF_8 ? value : value.encode("UTF-8", invalid: :replace, undef: :replace)
+        else value
+        end
+      end
+
       def body_size(captured, total)
         captured_size = captured.to_s.bytesize
         total ||= captured_size

data/lib/profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Profiler
-  VERSION = "0.34.3"
+  VERSION = "0.34.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-profiler
 version: !ruby/object:Gem::Version
-  version: 0.34.3
+  version: 0.34.5
 platform: ruby
 authors:
 - Sébastien Duplessy