skylight 3.1.4 → 5.3.4

data/lib/skylight/util/lru_cache.rb

@@ -0,0 +1,36 @@
+# Based on code by Sam Saffron: https://stackoverflow.com/a/16161783/181916
+module Skylight
+  module Util
+    class LruCache
+      def initialize(max_size)
+        @max_size = max_size
+        @data = {}
+      end
+
+      def max_size=(size)
+        raise ArgumentError, :max_size if @max_size < 1
+
+        @max_size = size
+        @data.shift while @data.size > @max_size
+      end
+
+      # Individual hash operations here are atomic in MRI.
+      def fetch(key)
+        found = true
+        value = @data.delete(key) { found = false }
+
+        value = yield if !found && block_given?
+
+        @data[key] = value if value
+
+        @data.shift if !found && value && @data.length > @max_size
+
+        value
+      end
+
+      def clear
+        @data.clear
+      end
+    end
+  end
+end

data/lib/skylight/util/platform.rb

@@ -0,0 +1,74 @@
+require "rbconfig"
+
+# Used from extconf and to load libskylight
+module Skylight
+  module Util
+    module Platform
+      # Normalize the platform OS
+      OS =
+        case os = RbConfig::CONFIG["host_os"].downcase
+        when /linux/
+          # The official ruby-alpine Docker containers pre-build Ruby. As a result,
+          #   Ruby doesn't know that it's on a musl-based platform. `ldd` is the
+          #   only reliable way to detect musl that we've found.
+          # See https://github.com/skylightio/skylight-ruby/issues/92
+          ENV.fetch("SKYLIGHT_MUSL") { `ldd --version 2>&1` =~ /musl/ } ? "linux-musl" : "linux"
+        when /darwin/
+          "darwin"
+        when /freebsd/
+          "freebsd"
+        when /netbsd/
+          "netbsd"
+        when /openbsd/
+          "openbsd"
+        when /sunos|solaris/
+          "solaris"
+        when /mingw|mswin/
+          "windows"
+        else
+          os
+        end
+
+      # Normalize the platform CPU
+      ARCH =
+        case cpu = RbConfig::CONFIG["host_cpu"].downcase
+        when /amd64|x86_64/
+          "x86_64"
+        when /i?86|x86|i86pc/
+          "x86"
+        when /ppc|powerpc/
+          "powerpc"
+        when /arm64|aarch64/
+          "aarch64"
+        else
+          cpu
+        end
+
+      LIBEXT =
+        case OS
+        when /darwin/
+          "dylib"
+        when /linux|bsd|solaris/
+          "so"
+        when /windows|cygwin/
+          "dll"
+        else
+          "so"
+        end
+
+      TUPLE = "#{ARCH}-#{OS}".freeze
+
+      def self.tuple
+        TUPLE
+      end
+
+      def self.libext
+        LIBEXT
+      end
+
+      def self.dlext
+        RbConfig::CONFIG["DLEXT"]
+      end
+    end
+  end
+end

data/lib/skylight/util/proxy.rb

@@ -0,0 +1,13 @@
+module Skylight
+  module Util
+    module Proxy
+      def self.detect_url(env)
+        u = env["HTTP_PROXY"] || env["http_proxy"]
+        if u && !u.empty?
+          u = "http://#{u}" unless u =~ %r{://}
+          u
+        end
+      end
+    end
+  end
+end

data/lib/skylight/util/ssl.rb

@@ -1,54 +1,30 @@
-require 'openssl'
+require "openssl"
 
 module Skylight
   module Util
     class SSL
-      DEFAULT_CA_FILE  = File.expand_path('../../data/cacert.pem', __FILE__)
+      DEFAULT_CA_FILE = File.expand_path("../data/cacert.pem", __dir__)
 
       def self.detect_ca_cert_file!
-        return nil if ENV['SKYLIGHT_FORCE_OWN_CERTS']
+        return nil if ENV["SKYLIGHT_FORCE_OWN_CERTS"]
 
         @ca_cert_file = false
         if defined?(OpenSSL::X509::DEFAULT_CERT_FILE)
           f = OpenSSL::X509::DEFAULT_CERT_FILE
 
-          if f && File.exist?(f)
-            @ca_cert_file = f
-          end
-        end
-      end
-
-      def self.detect_ca_cert_dir!
-        return nil if ENV['SKYLIGHT_FORCE_OWN_CERTS']
-
-        @ca_cert_dir = false
-        if defined?(OpenSSL::X509::DEFAULT_CERT_DIR)
-          d = OpenSSL::X509::DEFAULT_CERT_DIR
-
-          if d && File.exist?(d)
-            @ca_cert_dir = d
-          end
+          @ca_cert_file = f if f && File.exist?(f)
         end
       end
 
       detect_ca_cert_file!
-      detect_ca_cert_dir!
 
       def self.ca_cert_file?
         !!@ca_cert_file
       end
 
-      def self.ca_cert_dir?
-        !!@ca_cert_dir
-      end
-
       def self.ca_cert_file_or_default
         @ca_cert_file || DEFAULT_CA_FILE
       end
-
-      def self.ca_cert_dir
-        @ca_cert_dir
-      end
     end
   end
 end

data/lib/skylight/util.rb

@@ -0,0 +1,12 @@
+module Skylight
+  # @api private
+  module Util
+    # Used from the main lib
+    require "skylight/util/allocation_free"
+    require "skylight/util/clock"
+    require "skylight/util/instrumenter_method"
+
+    # Used from the CLI
+    autoload :Gzip, "skylight/util/gzip"
+  end
+end

data/lib/skylight/vendor/cli/thor/rake_compat.rb

@@ -11,7 +11,7 @@ class Thor
   #   class Default < Thor
   #     include Thor::RakeCompat
   #
-  #     RSpec::Core::RakeTask.new(:spec) do |t|
+  #     RSpec::RakeTask.new(:spec) do |t|
   #       t.spec_opts = ['--options', "./.rspec"]
   #       t.spec_files = FileList['spec/**/*_spec.rb']
   #     end

data/lib/skylight/version.rb

@@ -1,3 +1,7 @@
 module Skylight
-  VERSION = '3.1.4'
+  # pre-release versions should be given here as "5.0.0-alpha"
+  # 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 = "5.3.4".freeze
 end

data/lib/skylight/vm/gc.rb

@@ -0,0 +1,60 @@
+module Skylight
+  # @api private
+  module VM
+    if defined?(JRUBY_VERSION)
+      # This doesn't quite work as we would like it. I believe that the GC
+      # statistics includes time that is not stop-the-world, this does not
+      # necessarily take time away from the application.
+      #
+      # require 'java'
+      # class GC
+      #   def initialize
+      #     @factory = Java::JavaLangManagement::ManagementFactory
+      #   end
+      #
+      #   def enable
+      #   end
+      #
+      #   def total_time
+      #     res = 0.0
+      #
+      #     @factory.garbage_collector_mx_beans.each do |mx|
+      #       res += (mx.collection_time.to_f / 1_000.0)
+      #     end
+      #
+      #     res
+      #   end
+      # end
+    elsif defined?(::GC::Profiler)
+      class GC
+        def initialize
+          @total = 0
+        end
+
+        def enable
+          ::GC::Profiler.enable
+        end
+
+        def total_time
+          # Reported in seconds
+          run = (::GC::Profiler.total_time * 1_000_000).to_i
+
+          ::GC::Profiler.clear if run > 0
+
+          @total += run
+        end
+      end
+    end
+
+    # Fallback
+    unless defined?(VM::GC)
+      class GC
+        def enable; end
+
+        def total_time
+          0
+        end
+      end
+    end
+  end
+end

data/lib/skylight.rb

@@ -1,34 +1,223 @@
-require 'skylight/version'
-require 'skylight/core'
-require 'skylight/trace'
-require 'skylight/instrumenter'
-require 'skylight/middleware'
-require 'skylight/api'
-require 'skylight/helpers'
-require 'skylight/config'
-require 'skylight/errors'
-require 'skylight/native'
+require "skylight/version"
+require "skylight/trace"
+require "skylight/instrumenter"
+require "skylight/middleware"
+require "skylight/api"
+require "skylight/helpers"
+require "skylight/config"
+require "skylight/user_config"
+require "skylight/errors"
+require "skylight/native"
+require "skylight/gc"
+require "skylight/vm/gc"
+require "skylight/util"
+require "skylight/deprecation"
+require "skylight/subscriber"
+require "skylight/sidekiq"
+require "skylight/probes"
+
+# For prettier global names
+require "English"
+
+require "active_support/notifications"
+
+# Specifically check for Railtie since we've had at least one case of a
+#   customer having Rails defined without having all of Rails loaded.
+require "skylight/railtie" if defined?(Rails::Railtie)
 
 module Skylight
   # Used from the CLI
-  autoload :CLI, 'skylight/cli'
+  autoload :CLI, "skylight/cli"
 
-  # Specifically check for Railtie since we've had at least one case of a
-  #   customer having Rails defined without having all of Rails loaded.
-  if defined?(Rails::Railtie)
-    require 'skylight/railtie'
-  end
+  # Is this autoload even useful?
+  autoload :Normalizers, "skylight/normalizers"
 
-  include Core::Instrumentable
+  extend Util::Logging
 
-  def self.instrumenter_class
-    Instrumenter
-  end
+  LOCK = Mutex.new
 
-  def self.config_class
-    Config
-  end
+  # @api private
+  TIERS = %w[rack api app view db noise other].freeze
+
+  # @api private
+  TIER_REGEX = /^(?:#{TIERS.join("|")})(?:\.|$)/u.freeze
+
+  # @api private
+  CATEGORY_REGEX = /^[a-z0-9_-]+(?:\.[a-z0-9_-]+)*$/iu.freeze
+
+  # @api private
+  DEFAULT_CATEGORY = "app.block".freeze
+
+  # @api private
+  DEFAULT_OPTIONS = { category: DEFAULT_CATEGORY }.freeze
+
+  at_exit { stop! }
+
+  class << self
+    extend Util::InstrumenterMethod
+
+    def instrumenter
+      defined?(@instrumenter) && @instrumenter
+    end
+
+    def probe(*args)
+      Probes.probe(*args)
+    end
+
+    def enable_normalizer(*names)
+      Normalizers.enable(*names)
+    end
+
+    # Start instrumenting
+    def start!(config = nil)
+      return instrumenter if instrumenter
+
+      const_get(:LOCK).synchronize do
+        return instrumenter if instrumenter
+
+        config ||= {}
+        config = Config.load(config) unless config.is_a?(Config)
+
+        Probes.install!
+
+        @instrumenter = Instrumenter.new(config).start!
+      end
+    rescue StandardError => e
+      level, message =
+        if e.is_a?(ConfigError)
+          [:warn, format("Unable to start Instrumenter due to a configuration error: %<message>s", message: e.message)]
+        else
+          [
+            :error,
+            format("Unable to start Instrumenter; msg=%<message>s; class=%<klass>s", message: e.message, klass: e.class)
+          ]
+        end
+
+      if config.respond_to?("log_#{level}") && config.respond_to?(:log_trace)
+        config.send("log_#{level}", message)
+        config.log_trace e.backtrace.join("\n")
+      else
+        warn "[#{name.upcase}] #{message}"
+      end
+      false
+    end
+
+    def started?
+      !!instrumenter
+    end
 
-  Core::Probes.add_path(File.expand_path("skylight/probes", __dir__))
+    # Stop instrumenting
+    def stop!
+      t { "stop!" }
 
+      const_get(:LOCK).synchronize do
+        t { "stop! synchronized" }
+        return unless instrumenter
+
+        # This is only really helpful for getting specs to pass.
+        @instrumenter.current_trace = nil
+
+        @instrumenter.shutdown
+        @instrumenter = nil
+      end
+    end
+
+    # Check tracing
+    def tracing?
+      t { "checking tracing?; thread=#{Thread.current.object_id}" }
+      instrumenter&.current_trace
+    end
+
+    # Start a trace
+    def trace(endpoint = nil, cat = nil, title = nil, meta: nil, segment: nil, component: nil)
+      unless instrumenter
+        return yield if block_given?
+
+        return
+      end
+
+      if instrumenter.poisoned?
+        spawn_shutdown_thread!
+        return yield if block_given?
+
+        return
+      end
+
+      cat ||= DEFAULT_CATEGORY
+
+      if block_given?
+        instrumenter.trace(endpoint, cat, title, nil, meta: meta, segment: segment, component: component) do |tr|
+          yield tr
+        end
+      else
+        instrumenter.trace(endpoint, cat, title, nil, meta: meta, segment: segment, component: component)
+      end
+    end
+
+    # @overload instrument(opts)
+    #   @param [Hash] opts the options for instrumentation.
+    #   @option opts [String] :category (`DEFAULT_CATEGORY`) The category
+    #   @option opts [String] :title The title
+    #   @option opts [String] :description The description
+    #   @option opts [Hash] :meta The meta
+    #   @option opts [String] :source_location The source location
+    #   @option opts [String] :source_file The source file. (Will be sanitized.)
+    #   @option opts [String] :source_line The source line.
+    # @overload instrument(title)
+    #   Instrument with the specified title and the default category
+    #   @param [String] title The title
+    def instrument(opts = DEFAULT_OPTIONS, &block)
+      unless instrumenter
+        return yield if block_given?
+
+        return
+      end
+
+      if opts.is_a?(Hash)
+        category = opts[:category] || DEFAULT_CATEGORY
+        title = opts[:title]
+        desc = opts[:description]
+        meta = opts[:meta]
+      else
+        category = DEFAULT_CATEGORY
+        title = opts.to_s
+        desc = nil
+        meta = nil
+        opts = {}
+      end
+
+      # NOTE: unless we have `:internal` (indicating a built-in Skylight instrument block),
+      # or we already have a `source_file` or `source_line` (probably set by `instrument_method`),
+      # we set the caller location to the second item on the stack
+      # (immediate caller of the `instrument` method).
+      unless opts[:source_file] || opts[:source_line] || opts[:internal]
+        opts = opts.merge(sk_instrument_location: caller_locations(1..1).first)
+      end
+
+      meta ||= {}
+
+      instrumenter.extensions.process_instrument_options(opts, meta)
+      instrumenter.instrument(category, title, desc, meta, &block)
+    end
+
+    instrumenter_method :config
+
+    instrumenter_method :mute, block: true
+    instrumenter_method :unmute, block: true
+    instrumenter_method :muted?
+
+    # End a span
+    instrumenter_method :done
+
+    instrumenter_method :broken!
+
+    # Temporarily disable
+    instrumenter_method :disable, block: true
+
+    # Runs the shutdown procedure in the background.
+    # This should do little more than unsubscribe from all ActiveSupport::Notifications
+    def spawn_shutdown_thread!
+      @shutdown_thread || const_get(:LOCK).synchronize { @shutdown_thread ||= Thread.new { @instrumenter&.shutdown } }
+    end
+  end
 end