skylight 4.2.3 → 5.3.0

data/lib/skylight/util/gzip.rb

@@ -0,0 +1,20 @@
+require "zlib"
+
+module Skylight
+  module Util
+    # Provides Gzip compressing support
+    module Gzip
+      # Compress a string with Gzip
+      #
+      # @param str [String] uncompressed string
+      # @return [String] compressed string
+      def self.compress(str)
+        output = StringIO.new
+        gz = Zlib::GzipWriter.new(output)
+        gz.write(str)
+        gz.close
+        output.string
+      end
+    end
+  end
+end

data/lib/skylight/util/http.rb

@@ -3,23 +3,23 @@ require "json"
 require "openssl"
 require "net/http"
 require "net/https"
-require "skylight/core/util/gzip"
+require "skylight/util/gzip"
 require "skylight/util/ssl"
 
 module Skylight
   module Util
     class HTTP
       CONTENT_ENCODING = "content-encoding".freeze
-      CONTENT_LENGTH   = "content-length".freeze
-      CONTENT_TYPE     = "content-type".freeze
-      ACCEPT           = "Accept".freeze
-      X_VERSION_HDR    = "x-skylight-agent-version".freeze
+      CONTENT_LENGTH = "content-length".freeze
+      CONTENT_TYPE = "content-type".freeze
+      ACCEPT = "Accept".freeze
+      X_VERSION_HDR = "x-skylight-agent-version".freeze
       APPLICATION_JSON = "application/json".freeze
-      AUTHORIZATION    = "authorization".freeze
-      DEFLATE          = "deflate".freeze
-      GZIP             = "gzip".freeze
+      AUTHORIZATION = "authorization".freeze
+      DEFLATE = "deflate".freeze
+      GZIP = "gzip".freeze
 
-      include Core::Util::Logging
+      include Logging
 
       attr_accessor :authentication
       attr_reader :host, :port, :config
@@ -35,7 +35,8 @@ module Skylight
         end
       end
 
-      class ReadResponseError < StandardError; end
+      class ReadResponseError < StandardError
+      end
 
       def initialize(config, service = :auth, opts = {})
         @config = config
@@ -46,7 +47,7 @@ module Skylight
 
         url = URI.parse(url)
 
-        @ssl  = url.scheme == "https"
+        @ssl = url.scheme == "https"
         @host = url.host
         @port = url.port
 
@@ -81,137 +82,129 @@ module Skylight
 
       private
 
-        def get_timeout(type, config, service, opts)
-          config.duration_ms("#{service}_http_#{type}_timeout") ||
-            opts[:timeout] || 15
-        end
+      def get_timeout(type, config, service, opts)
+        config.duration_ms("#{service}_http_#{type}_timeout") || opts[:timeout] || 15
+      end
 
-        def build_request(type, endpoint, hdrs, length = nil)
-          headers = {}
+      def build_request(type, endpoint, hdrs, length = nil)
+        headers = {}
 
-          headers[CONTENT_LENGTH]   = length.to_s if length
-          headers[AUTHORIZATION]    = authentication if authentication
-          headers[ACCEPT]           = APPLICATION_JSON
-          headers[X_VERSION_HDR]    = VERSION
-          headers[CONTENT_ENCODING] = GZIP if length && @deflate
+        headers[CONTENT_LENGTH] = length.to_s if length
+        headers[AUTHORIZATION] = authentication if authentication
+        headers[ACCEPT] = APPLICATION_JSON
+        headers[X_VERSION_HDR] = VERSION
+        headers[CONTENT_ENCODING] = GZIP if length && @deflate
 
-          hdrs.each do |k, v|
-            headers[k] = v
-          end
+        hdrs.each { |k, v| headers[k] = v }
 
-          type.new(endpoint, headers)
+        type.new(endpoint, headers)
+      end
+
+      def do_request(http, req)
+        begin
+          client = http.start
+        rescue StandardError => e
+          # TODO: Retry here
+          raise StartError, e
         end
 
-        def do_request(http, req)
-          begin
-            client = http.start
-          rescue => e
-            # TODO: Retry here
-            raise StartError, e
-          end
+        begin
+          res = client.request(req)
+        rescue *READ_EXCEPTIONS => e
+          raise ReadResponseError, e.inspect
+        end
 
-          begin
-            res = client.request(req)
-          rescue *READ_EXCEPTIONS => e
-            raise ReadResponseError, e.inspect
-          end
+        yield res
+      ensure
+        client&.finish
+      end
 
-          yield res
-        ensure
-          client.finish if client
+      def execute(req, body = nil)
+        t do
+          fmt "executing HTTP request; host=%s; port=%s; path=%s, body=%s",
+              @host,
+              @port,
+              req.path,
+              body && body.bytesize
         end
 
-        def execute(req, body = nil)
-          t do
-            fmt "executing HTTP request; host=%s; port=%s; path=%s, body=%s",
-                @host, @port, req.path, body && body.bytesize
-          end
+        if body
+          body = Gzip.compress(body) if @deflate
+          req.body = body
+        end
 
-          if body
-            body = Gzip.compress(body) if @deflate
-            req.body = body
-          end
+        http = Net::HTTP.new(@host, @port, @proxy_addr, @proxy_port, @proxy_user, @proxy_pass)
 
-          http = Net::HTTP.new(@host, @port,
-                               @proxy_addr, @proxy_port, @proxy_user, @proxy_pass)
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
 
-          http.open_timeout = @open_timeout
-          http.read_timeout = @read_timeout
+        if @ssl
+          http.use_ssl = true
 
-          if @ssl
-            http.use_ssl = true
+          http.ca_file = SSL.ca_cert_file_or_default unless SSL.ca_cert_file?
 
-            unless SSL.ca_cert_file?
-              http.ca_file = SSL.ca_cert_file_or_default
-            end
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
 
-            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        do_request(http, req) do |res|
+          unless res.code =~ /2\d\d/
+            debug "server responded with #{res.code}"
+            t { fmt "body=%s", res.body }
           end
 
-          do_request(http, req) do |res|
-            unless res.code =~ /2\d\d/
-              debug "server responded with #{res.code}"
-              t { fmt "body=%s", res.body }
-            end
+          Response.new(res.code.to_i, res, res.body)
+        end
+      rescue Exception => e
+        error "http %s %s failed; error=%s; msg=%s", req.method, req.path, e.class, e.message
+        t { e.backtrace.join("\n") }
+        ErrorResponse.new(req, e)
+      end
 
-            Response.new(res.code.to_i, res, res.body)
-          end
-        rescue Exception => e
-          error "http %s %s failed; error=%s; msg=%s", req.method, req.path, e.class, e.message
-          t { e.backtrace.join("\n") }
-          ErrorResponse.new(req, e)
-        end
-
-        class Response
-          attr_reader :status, :headers, :body, :exception
-
-          def initialize(status, headers, body)
-            @status  = status
-            @headers = headers
-
-            if (headers[CONTENT_TYPE] || "").include?(APPLICATION_JSON)
-              begin
-                @body = JSON.parse(body)
-              rescue JSON::ParserError
-                @body = body # not really JSON I guess
-              end
-            else
-              @body = body
-            end
-          end
+      class Response
+        attr_reader :status, :headers, :body, :exception
 
-          def success?
-            status >= 200 && status < 300
-          end
+        def initialize(status, headers, body)
+          @status = status
+          @headers = headers
 
-          def to_s
-            body.to_s
+          if (headers[CONTENT_TYPE] || "").include?(APPLICATION_JSON)
+            begin
+              @body = JSON.parse(body)
+            rescue JSON::ParserError
+              @body = body # not really JSON I guess
+            end
+          else
+            @body = body
           end
+        end
 
-          def get(key)
-            return nil unless body.is_a?(Hash)
+        def success?
+          status >= 200 && status < 300
+        end
 
-            res = body
-            key.split(".").each do |part|
-              return unless (res = res[part])
-            end
-            res
-          end
+        def to_s
+          body.to_s
+        end
 
-          def respond_to_missing?(name, include_all = false)
-            super || body.respond_to?(name, include_all)
-          end
+        def get(key)
+          body.dig(*key.split(".")) if body.is_a?(Hash)
+        end
 
-          def method_missing(name, *args, &blk)
-            if respond_to_missing?(name)
-              body.send(name, *args, &blk)
-            else
-              super
-            end
+        def respond_to_missing?(name, include_all = false)
+          super || body.respond_to?(name, include_all)
+        end
+
+        def method_missing(name, *args, &blk)
+          if respond_to_missing?(name)
+            body.send(name, *args, &blk)
+          else
+            super
           end
         end
+      end
 
-        ErrorResponse = Struct.new(:request, :exception) do
+      ErrorResponse =
+        Struct.new(:request, :exception) do
           def status
             nil
           end

data/lib/skylight/util/instrumenter_method.rb

@@ -0,0 +1,26 @@
+module Skylight
+  module Util
+    module InstrumenterMethod
+      def instrumenter_method(name, block: false)
+        if block
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(*args)                      # def mute(*args)
+              unless instrumenter                   #   unless instrumenter
+                return yield if block_given?        #     return yield if block_given?
+                return                              #     return
+              end                                   #   end
+                                                    #
+              instrumenter.#{name}(*args) { yield } #   instrumenter.mute(*args) { yield }
+            end                                     # end
+          RUBY
+        else
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(*args)              # def config(*args)
+              instrumenter&.#{name}(*args)  #   instrumenter&.config(*args)
+            end                             # end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/skylight/util/logging.rb

@@ -0,0 +1,136 @@
+require "logger"
+
+module Skylight
+  module Util
+    # Log both to the specified logger and STDOUT
+    class AlertLogger
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def write(*args)
+        $stderr.write(*args)
+
+        # Try to avoid writing to STDOUT/STDERR twice
+        logger_logdev = @logger.instance_variable_get(:@logdev)
+        logger_out = logger_logdev.respond_to?(:dev) ? logger_logdev.dev : nil
+        @logger.<<(*args) if logger_out != $stdout && logger_out != $stderr
+      end
+
+      def close; end
+    end
+
+    module Logging
+      def log_context
+        {}
+      end
+
+      def trace?
+        !!ENV[-"SKYLIGHT_ENABLE_TRACE_LOGS"]
+      end
+
+      def raise_on_error?
+        !!ENV[-"SKYLIGHT_RAISE_ON_ERROR"]
+      end
+
+      # Logs if tracing
+      #
+      # @param (see #debug)
+      #
+      # See {trace?}.
+      def trace(msg, *args)
+        return unless trace?
+
+        log :debug, msg, *args
+      end
+
+      # Evaluates and logs the result of the block if tracing
+      #
+      # @yield block to be evaluted
+      # @yieldreturn arguments for {#debug}
+      #
+      # See {trace?}.
+      def t
+        return unless trace?
+
+        log :debug, yield
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def debug(msg, *args)
+        log :debug, msg, *args
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def info(msg, *args)
+        log :info, msg, *args
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def warn(msg, *args)
+        log :warn, msg, *args
+      end
+
+      # @param msg (see #log)
+      # @param args (see #log)
+      def error(msg, *args)
+        log :error, msg, *args
+        raise format(msg, *args) if raise_on_error?
+      end
+
+      alias log_trace trace
+      alias log_debug debug
+      alias log_info info
+      alias log_warn warn
+      alias log_error error
+
+      # Alias for `Kernel#sprintf`
+      # @return [String]
+      def fmt(*args)
+        sprintf(*args)
+      end
+
+      def config_for_logging
+        if respond_to?(:config)
+          config
+        elsif is_a?(Skylight::Config)
+          self
+        end
+      end
+
+      # @param level [String,Symbol] the method on `logger` to use for logging
+      # @param msg [String] the message to log
+      # @param args [Array] values for `Kernel#sprintf` on `msg`
+      def log(level, msg, *args)
+        c = config_for_logging
+        logger = c ? c.logger : nil
+
+        msg = log_context.map { |(k, v)| "#{k}=#{v}; " }.join << msg
+
+        if logger
+          if logger.respond_to?(level)
+            if args.empty?
+              logger.send level, msg
+            else
+              logger.send level, format(msg, *args)
+            end
+            return # rubocop:disable Style/RedundantReturn
+          else
+            Kernel.warn "Invalid logger"
+          end
+          # Fallback to stderr for warn and error levels
+        elsif %i[warn error].include?(level)
+          $stderr.puts format("[SKYLIGHT] #{msg}", *args)
+        end
+      rescue Exception => e
+        if trace?
+          puts "[ERROR] #{e.message}"
+          puts e.backtrace
+        end
+      end
+    end
+  end
+end

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

@@ -12,11 +12,7 @@ module Skylight
           #   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
-          if ENV["SKYLIGHT_MUSL"] || `ldd --version 2>&1` =~ /musl/
-            "linux-musl"
-          else
-            "linux"
-          end
+          ENV["SKYLIGHT_MUSL"] || `ldd --version 2>&1` =~ /musl/ ? "linux-musl" : "linux"
         when /darwin/
           "darwin"
         when /freebsd/
@@ -42,8 +38,8 @@ module Skylight
           "x86"
         when /ppc|powerpc/
           "powerpc"
-        when /^arm/
-          "arm"
+        when /arm64|aarch64/
+          "aarch64"
         else
           cpu
         end

data/lib/skylight/util/ssl.rb

@@ -12,43 +12,19 @@ module Skylight
         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
-
-      class << self
-        attr_reader :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 = "4.2.3".freeze
+  # 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.0".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