skylight 7.1.1 → 7.2.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb1aa9e97569dad5f875188d9b9950ce95e2f760cecbf47e56d1a111a3bb3d4b
-  data.tar.gz: 077b6c9517691116e216022f9f5e810edc7173c262a66d99446b49341efbe51a
+  metadata.gz: dccfccf293fe88129f1bb1e0ae18e6bc8f242e1d9cb06ce3cdf7af0d47f5c77f
+  data.tar.gz: 99feb9962ef72af53930bdd89f25fad9cfd2943abbe4c5f3806bb768975c61b7
 SHA512:
-  metadata.gz: 28a23bdc8e24bd10150a23d917bb669cdebfafb5422046f9c1fe7c0aebee7a12e2f31ca8aee12430e50e32956ef54581b63481f81616fdcf2edecf41ab86ddc2
-  data.tar.gz: c41a8135ee576517a9f1f4f096fc9bb30f024e45e1918a3c19ca21e480f21b9ddecba70527734a660fe9723bc25feffcaae605bc0966d4d19a488b308d66166b
+  metadata.gz: 9b78cdd01a03ccc74916c20de4a857592e52c95d087542b9adaa3c685429d8317f36879a25fb28f23ec07bcb81caf6b6829a7306b40c44dc7f000d00b20bd320
+  data.tar.gz: dfcd97b684460f645c3b8e828cec9f326e0b896204114f87a633f3b4c0657cf8761961d7fd47bc908f36ab62f26e7f87240179f1e6f818d9f17c1dae365c6665

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 7.2.0.beta (November 4, 2026)
+- BUGFIX Don't trigger the `Mime::SET` deprecation warning on Rails 8.2.
+- IMPROVEMENT The `redis` probe now instruments redis-client, including when it's used without the redis gem (e.g. by Sidekiq 7+). With redis 5+, which is built on redis-client, blocking commands (e.g. `BLPOP`) are now instrumented too.
+- IMPROVEMENT Redis connections, including TLS and the connection handshake, are now recorded as their own `CONNECT` span instead of being counted toward the command that opened them.
+- IMPROVEMENT With redis 5+, `PIPELINE` and `MULTI` spans now cover only the round trip to Redis, not the time spent running the block. Empty pipelines are no longer recorded.
+- BUGFIX Don't report a probe installation error when a `Redis` constant is defined by something other than the redis gem.
+- BUGFIX Reduce the overhead of source location tracking. File paths are now classified once and cached, rather than re-processed for every span.
+- BUGFIX Fix Grape endpoint names on Grape 4.0+.
+
 ## 7.1.1 (April 17, 2026)
 - BUGFIX Fix native extension build on GCC 15 by using `append_cflags` instead of mutating `$CFLAGS` directly.
 - BUGFIX Replace K&R-style empty parameter lists (`()`) with `(void)` in C sources to build cleanly under Fedora's `-Werror=old-style-definition`.

data/lib/skylight/extensions/source_location.rb

@@ -13,11 +13,23 @@ module Skylight
       META_KEYS = %i[source_location source_file source_line].freeze
       MAX_CALLER_DEPTH = 75
 
+      # Upper bound for each path cache. These are keyed by file path, so in practice they're bounded by
+      # the number of files that show up in backtraces; the limit only guards against pathological growth.
+      PATH_CACHE_MAX_SIZE = 10_000
+
       def initialize(*)
         super
         cache_size = (config[:source_location_cache_size] || 1000).to_i
-        @caller_cache = Util::LruCache.new(cache_size)
         @instance_method_source_location_cache = Util::LruCache.new(cache_size)
+
+        # path (by value) => [sanitized_path, include_line] or false
+        @path_info_cache = {}
+
+        # Same as above, but keyed by object identity. Ruby interns the path of each loaded file,
+        # so every backtrace location in a given file returns the same String object from
+        # `absolute_path`, which makes this a cheap lookup while walking frames.
+        @frame_path_info_cache = {}.compare_by_identity
+
         gem_require_trie # memoize this at startup
       end
 
@@ -53,7 +65,7 @@ module Skylight
           meta[:source_line] = instrument_location.lineno
         else
           warn "Ignoring source_line without source_file" if source_line
-          if (location = find_caller(cache_key: opts.hash))
+          if (location = find_caller)
             meta[:source_file] = location.absolute_path
             meta[:source_line] = location.lineno
           end
@@ -75,10 +87,10 @@ module Skylight
             [opts[:source_file], opts[:source_line]]
           end
 
-        sl ||= source_location(payload, meta, cache_key: opts[:cache_key])
+        sl ||= source_location(payload, meta)
 
         if sl
-          trace("normalizer source_location=#{sl}")
+          t { "normalizer source_location=#{sl}" }
           meta[:source_file], meta[:source_line] = sl
         end
 
@@ -105,7 +117,7 @@ module Skylight
           warn "Ignoring source_line without source_file; source_line=#{source_line}"
         end
 
-        trace("source_location=#{meta[:source_location]}") if meta[:source_location]
+        t { "source_location=#{meta[:source_location]}" } if meta[:source_location]
       end
 
       def allowed_meta_keys
@@ -122,27 +134,21 @@ module Skylight
 
       # from normalizers.rb
       # Returns an array of file and line
-      def source_location(payload, meta, cache_key: nil)
+      def source_location(payload, meta)
         # FIXME: what should precedence be?
         if meta.is_a?(Hash) && meta[:source_location]
           meta.delete(:source_location)
         elsif payload.is_a?(Hash) && payload[:sk_source_location]
           payload[:sk_source_location]
-        elsif (location = find_caller(cache_key: cache_key))
+        elsif (location = find_caller)
           [location.absolute_path, location.lineno]
         end
       end
 
-      def find_caller(cache_key: nil)
-        # starting at 4 to skip Skylight extension processing logic
-        locations = ::Kernel.caller_locations(4..MAX_CALLER_DEPTH)
-
-        if cache_key
-          localized_cache_key = [cache_key, locations.map(&:lineno)].hash
-          @caller_cache.fetch(localized_cache_key) { find_caller_inner(locations) }
-        else
-          find_caller_inner(locations)
-        end
+      # Returns the first location (starting at 4 to skip Skylight extension processing logic)
+      # that is in a non-ignored gem or in the project.
+      def find_caller
+        ::Kernel.caller_locations(4..MAX_CALLER_DEPTH).find { |l| frame_path_info(l.absolute_path) }
       end
 
       def project_path?(path)
@@ -189,23 +195,45 @@ module Skylight
       end
 
       def sanitize_source_location(path, line)
-        # Do this first since gems may be vendored in the app repo. However, it might be slower.
-        # Should we cache matches?
+        return unless (info = path_info(path))
+
+        sanitized_path, include_line = info
+        include_line && line ? "#{sanitized_path}:#{line}" : sanitized_path
+      end
+
+      private
+
+      def path_info(path)
+        return false unless path
+
+        @path_info_cache.fetch(path) do
+          @path_info_cache.clear if @path_info_cache.size >= PATH_CACHE_MAX_SIZE
+          @path_info_cache[path] = compute_path_info(path)
+        end
+      end
+
+      def frame_path_info(path)
+        return false unless path
+
+        @frame_path_info_cache.fetch(path) do
+          @frame_path_info_cache.clear if @frame_path_info_cache.size >= PATH_CACHE_MAX_SIZE
+          @frame_path_info_cache[path] = path_info(path)
+        end
+      end
+
+      # Returns [sanitized_path, include_line], or false if the path should not be reported.
+      # Gems are reported by name only; project files relative to the root, with a line number.
+      def compute_path_info(path)
+        # Do this first since gems may be vendored in the app repo.
         if (gem_name = find_source_gem(path))
-          path = gem_name
-          line = nil
+          [gem_name, false].freeze
         elsif project_path?(path)
-          # Get relative path to root
-          path = Pathname.new(path).relative_path_from(config.root).to_s
+          [Pathname.new(path).relative_path_from(config.root).to_s.freeze, true].freeze
         else
-          return
+          false
         end
-
-        line ? "#{path}:#{line}" : path
       end
 
-      private
-
       def gem_require_trie
         @gem_require_trie ||=
           begin
@@ -248,15 +276,6 @@ module Skylight
         nil
       end
 
-      def find_caller_inner(locations)
-        # Start at file before this one
-        # NOTE: We could start farther back now to avoid more Skylight files
-        locations.find do |l|
-          absolute_path = l.absolute_path
-          find_source_gem(absolute_path) || project_path?(absolute_path)
-        end
-      end
-
       # walks up the inheritance tree until it finds the last method
       # without a super_method definition.
       def find_instance_method_super(constant, method_name)

data/lib/skylight/normalizers/action_controller/send_file.rb

@@ -1,49 +1,21 @@
 module Skylight
   module Normalizers
     module ActionController
-      enabled = true
+      class SendFile < Normalizer
+        register "send_file.action_controller"
 
-      # Temporary hacks
-      begin
-        require "action_dispatch/http/mime_type"
-        require "action_dispatch/http/mime_types"
-        require "rack/utils"
-      rescue LoadError
-        enabled = false
-      end
-
-      if enabled
-        class SendFile < Normalizer
-          register "send_file.action_controller"
-
-          CAT = "app.controller.send_file".freeze
-          TITLE = "send file".freeze
-
-          def normalize(_trace, _name, _payload)
-            title = TITLE
-
-            # depending on normalization, we probably want this to eventually
-            # include the full path, but we need to make sure we have a good
-            # deduping strategy first.
-            desc = nil
-
-            [CAT, title, desc]
-          end
-
-          private
+        CAT = "app.controller.send_file".freeze
+        TITLE = "send file".freeze
 
-          OCTET_STREAM = "application/octet-stream".freeze
-          ATTACHMENT = "attachment".freeze
+        def normalize(_trace, _name, _payload)
+          title = TITLE
 
-          def initialize(*)
-            super
+          # depending on normalization, we probably want this to eventually
+          # include the full path, but we need to make sure we have a good
+          # deduping strategy first.
+          desc = nil
 
-            @mimes =
-              Mime::SET.each_with_object({}) do |mime, hash|
-                hash[mime.symbol] = mime.to_s.dup.freeze
-                hash
-              end
-          end
+          [CAT, title, desc]
         end
       end
     end

data/lib/skylight/normalizers/grape/endpoint.rb

@@ -9,13 +9,33 @@ module Skylight
         private
 
         def get_method(endpoint)
-          method = endpoint.options[:method].first
-          method = "#{method}..." if endpoint.options[:method].length > 1
+          methods = http_methods(endpoint)
+          method = methods.first
+          method = "#{method}..." if methods.length > 1
           method
         end
 
         def get_path(endpoint)
-          endpoint.options[:path].join("/")
+          paths(endpoint).join("/")
+        end
+
+        # Grape 4+ no longer keeps an endpoint's methods, paths and API in `options`
+
+        def http_methods(endpoint)
+          # There's no public reader for these. Routes have them, but the endpoint here
+          # is a per-request copy that rebuilds its routes on every call, and automatic
+          # OPTIONS and 405 responses run on a route that has no endpoint to ask.
+          endpoint.options[:method] || endpoint.send(:config).http_methods
+        end
+
+        def paths(endpoint)
+          endpoint.options[:path] ||
+            # Grape 4.0 has no public reader for these (Endpoint#path arrived in 4.1)
+            (endpoint.respond_to?(:path) ? endpoint.path : endpoint.send(:config).path)
+        end
+
+        def api(endpoint)
+          endpoint.options[:for] || endpoint.api
         end
 
         def get_namespace(endpoint)

data/lib/skylight/normalizers/grape/endpoint_run.rb

@@ -28,7 +28,7 @@ module Skylight
         end
 
         def base_app_name(endpoint)
-          ep = endpoint.options[:for]
+          ep = api(endpoint)
           return ep.name if ep.name
 
           if ep.respond_to?(:base) && ep.base.respond_to?(:name)

data/lib/skylight/normalizers.rb

@@ -65,12 +65,11 @@ module Skylight
 
       def normalize_with_meta(trace, name, payload)
         # If we have a normal response but no meta, add it
-        cat, title, desc, meta = ret = normalize(trace, name, payload)
+        cat, title, desc, meta = normalize(trace, name, payload)
         return cat if cat == :skip
 
         meta ||= {}
-        cache_key = ret.hash
-        process_meta(trace, name, payload, meta, cache_key: cache_key)
+        process_meta(trace, name, payload, meta)
 
         [cat, title, desc, meta]
       end
@@ -80,13 +79,8 @@ module Skylight
 
       private
 
-      def process_meta(trace, _name, payload, meta, cache_key: nil)
-        trace.instrumenter.extensions.process_normalizer_meta(
-          payload,
-          meta,
-          cache_key: cache_key,
-          **process_meta_options(payload)
-        )
+      def process_meta(trace, _name, payload, meta)
+        trace.instrumenter.extensions.process_normalizer_meta(payload, meta, **process_meta_options(payload))
       end
 
       def process_meta_options(_payload)

data/lib/skylight/probes/redis.rb

@@ -8,6 +8,9 @@ module Skylight
 
       MULTI_OPTS = { category: "db.redis.multi".freeze, title: "MULTI".freeze, internal: true }.freeze
 
+      CONNECT_OPTS = { category: "db.redis.connect".freeze, title: "CONNECT".freeze, internal: true }.freeze
+
+      # redis < 5
       module ClientInstrumentation
         def call(command, *)
           command_name = command[0]
@@ -20,18 +23,6 @@ module Skylight
         end
       end
 
-      module ClientInstrumentationV5
-        def call_v(command)
-          command_name = command[0]
-
-          return super if command_name == :auth
-
-          opts = { category: "db.redis.command", title: command_name.upcase.to_s, internal: true }
-
-          Skylight.instrument(opts) { super }
-        end
-      end
-
       module Instrumentation
         def pipelined(*)
           Skylight.instrument(PIPELINED_OPTS) { super }
@@ -44,6 +35,17 @@ module Skylight
 
       class Probe
         def install
+          # A `Redis` namespace from something other than the redis gem; nothing to patch.
+          # (redis-client, if present, is installed by its own registration below.)
+          return unless defined?(::Redis::Client)
+
+          # redis 5+ is built on redis-client, which is instrumented below. Patching Redis
+          # as well would record each command twice.
+          if defined?(::RedisClient) && ::Redis::Client < ::RedisClient
+            Skylight::Probes.install_probe(Skylight::Probes.registered.fetch(:redis_client))
+            return
+          end
+
           version = defined?(::Redis::VERSION) ? Gem::Version.new(::Redis::VERSION) : nil
 
           if !version || version < Gem::Version.new("3.0.0")
@@ -52,17 +54,57 @@ module Skylight
             return
           end
 
-          if ::Redis::Client.method_defined?(:call_v)
-            ::Redis::Client.prepend(ClientInstrumentationV5)
-          else
-            ::Redis::Client.prepend(ClientInstrumentation)
+          ::Redis::Client.prepend(ClientInstrumentation)
+          ::Redis.prepend(Instrumentation)
+        end
+      end
+
+      # redis-client is used directly by e.g. Sidekiq 7+, and by redis 5+ under the hood.
+      module RedisClient
+        # Registered globally, so this applies to every RedisClient instance.
+        module Middleware
+          def call(command, _config)
+            command_name = command[0].to_s
+
+            return super if command_name.casecmp?("auth")
+
+            opts = { category: "db.redis.command", title: command_name.upcase, internal: true }
+
+            Skylight.instrument(opts) { super }
           end
 
-          ::Redis.prepend(Instrumentation)
+          def call_pipelined(commands, _config)
+            # Transactions are sent as a pipeline wrapped in MULTI ... EXEC
+            opts = commands.dig(0, 0).to_s.casecmp?("multi") ? MULTI_OPTS : PIPELINED_OPTS
+
+            Skylight.instrument(opts) { super }
+          end
+        end
+
+        # Covers the whole connection setup: the socket (and TLS) connect, plus the handshake
+        # (HELLO/AUTH/SELECT, etc.). The handshake goes through the middleware as an ordinary
+        # pipeline, with nothing to tell it apart from the user's, so it's muted here.
+        # `connect` is private, so accept any arguments in case its signature changes.
+        module ConnectInstrumentation
+          private
+
+          def connect(*, **)
+            Skylight.instrument(CONNECT_OPTS) { Skylight.mute { super } }
+          end
+        end
+
+        class Probe
+          def install
+            ::RedisClient.register(Middleware)
+            ::RedisClient.prepend(ConnectInstrumentation)
+          end
         end
       end
     end
 
+    # A single `redis` probe covers both gems: redis-client is often used without redis
+    # (e.g. by Sidekiq 7+), and either may be loaded first.
     register(:redis, "Redis", "redis", Redis::Probe.new)
+    register(:redis_client, "RedisClient", %w[redis-client redis_client], Redis::RedisClient::Probe.new)
   end
 end

data/lib/skylight/version.rb

@@ -3,5 +3,5 @@ module Skylight
   # for compatibility with semver when it is parsed by the rust agent.
   # This string will be transformed in the gemspec to "5.0.0.alpha"
   # to conform with rubygems.
-  VERSION = "7.1.1".freeze
+  VERSION = "7.2.0-beta".freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: skylight
 version: !ruby/object:Gem::Version
-  version: 7.1.1
+  version: 7.2.0.beta
 platform: ruby
 authors:
 - Tilde, Inc.