skylight 4.2.3 → 5.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4cafddf94ef05049d8240fe3b44c1c35d66505ca6e8f4913b7ebe4ddf1ef10c6
-  data.tar.gz: 6648e03d56f0a5216a57804fa44cdfd63155e2665fb49e534535f065702c2620
+  metadata.gz: c951c13914411fa23c37504ba022bd55229c2c4c59dc4dcf0a751b24b9dad33c
+  data.tar.gz: 93734aa403e74cbcc5c7afda5473800b962a1fe4a0b06fff0cbfab2a23d7d316
 SHA512:
-  metadata.gz: 7eb897a9c5984eb831de3af1681fb5ac47ff2314291594f342605c8ff0295eb0dd25d7c0a66965aea8506f5df41af5ca2bf7788a251caa58d871571f08205f95
-  data.tar.gz: ef2fbfc2446f76df58f94fabcb9fe39bf255d05df5b30fce042d44b71360b0052c0b18741250cd32ce967dd4eb0019396d61ae1589448e9fa062be60ebae7fb0
+  metadata.gz: 7901ffd7e863387424ab384d8276472a6d2c3dfabef2075cb859db8e1ff8f81643cce80f2ac9ffba1f3cb1c27d06338a6b6477347f7e7db58745d9ede000a78b
+  data.tar.gz: a404ebc97ac20f763f21df54e444e0abf72b4ad442bb39efca1c6b19a408f0d8edab2021032237aac044cb39c333815ed101ad6015fdd4246d3a66932cd9b7e9

data/CHANGELOG.md

@@ -1,5 +1,37 @@
-## 4.2.3 (March 10, 2020)
-* [BUGFIX] Fix an issue where the GraphQL probe may not always be installed
+## 5.0.0.beta3
+* [IMPROVEMENT] Optimizations for the Source Locations extension
+* [FEATURE] Configuration for the Source Locations caches via `SYLIGHT_SOURCE_LOCATION_CACHE_SIZE`
+* [BUGFIX] Fix issue with missing metadata in MongoDB probe
+* [BUGFIX] Resolve an inability to parse certain SQL queries containing arrays
+
+## 5.0.0.beta2
+* [FEATURE] Source Locations detection and reporting is now enabled by default (can be disabled with `SKYLIGHT_ENABLE_SOURCE_LOCATIONS=false`)
+* [BREAKING] Rename `environment` keyword argument to `priority_key`. Note `env` has not changed.
+* [BREAKING] Drop support for Ruby 2.4
+* [IMPROVEMENT] Improved Delayed::Job probe
+
+## 5.0.0.beta
+* [BREAKING] Merge skylight-core into skylight. All classes previously namespaced under `Skylight::Core` have been moved to `Skylight`.
+* [BREAKING] Remove `Skylight::Util::Inflector`
+* [BREAKING] Drop support for Rails 4
+* [BREAKING] Drop support for Ruby 2.3
+* [IMPROVEMENT] Maintain method visibility when instrumenting with `instrument_method`
+* [IMPROVEMENT] Update probes to use `Module#prepend` where possible
+* [IMPROVEMENT] New tokio-based skylightd
+* [IMPROVEMENT] Support `render_layout` notifications in Rails 6.1
+* [IMPROVEMENT] Support `ActionMailer::MailDeliveryJob` in Rails 6.1
+* [IMPROVEMENT] Better logging config
+* [BUGFIX] Allow multiple probes to be registered under the same key
+* [BUGFIX] Do not refer to Redis constant until the probe is installed
+* [BUGFIX] Fix nested calls to `Normalizers::Faraday::Request.disable`
+
+## 4.3.1 (June 24, 2020)
+* [BUGFIX] Fix an issue in which `Mime::NullType` would result in an exception
+
+## 4.3.0 (March 18, 2020)
+* [IMPROVEMENT] Fix Ruby 2.7 warnings
+* [IMPROVEMENT] Update Grape normalizer for version 1.3.1
+* [BUGFIX] Fix an issue where GraphQL normalizers could fail to load in non-Rails contexts
 
 ## 4.2.2 (February 25, 2020)
 * Support graphql-ruby version 1.10

data/CONTRIBUTING.md

@@ -18,12 +18,6 @@ If you prefer to run tests in your own environment, you may do so as follows:
 # Select a gemfile and bundle install
 export BUNDLE_GEMFILE=$PWD/gemfiles/Gemfile.rails-5.2.x
 bundle install
-
-# Run the skylight-core test suite (takes a few seconds)
-pushd skylight-core
-bundle exec rspec
-popd
-
-# Run the main test suite (takes 5-10 minutes)
+# Run the test suite (takes 5-10 minutes)
 bundle exec rspec
 ```

data/ext/extconf.rb

@@ -32,7 +32,8 @@ SKYLIGHT_FETCH_LIB  = !ENV.key?("SKYLIGHT_FETCH_LIB") || ENV["SKYLIGHT_FETCH_LIB
 
 # Directory where skylight.h exists
 SKYLIGHT_HDR_PATH = ENV["SKYLIGHT_HDR_PATH"] || ENV["SKYLIGHT_LIB_PATH"] || "."
-SKYLIGHT_LIB_PATH = ENV["SKYLIGHT_LIB_PATH"] || File.expand_path("../../lib/skylight/native/#{Platform.tuple}", __FILE__)
+SKYLIGHT_LIB_PATH = ENV["SKYLIGHT_LIB_PATH"] ||
+                    File.expand_path("../../lib/skylight/native/#{Platform.tuple}", __FILE__)
 
 SKYLIGHT_SOURCE_URL = ENV["SKYLIGHT_SOURCE_URL"]
 SKYLIGHT_VERSION = ENV["SKYLIGHT_VERSION"]
@@ -41,7 +42,7 @@ SKYLIGHT_CHECKSUM = ENV["SKYLIGHT_CHECKSUM"]
 SKYLIGHT_EXT_STRICT = ENV.key?("SKYLIGHT_EXT_STRICT") && ENV["SKYLIGHT_EXT_STRICT"] =~ /^true$/i
 
 # Setup logger
-LOG = Logger.new(MultiIO.new(STDOUT, File.open(SKYLIGHT_INSTALL_LOG, "a")))
+LOG = Logger.new(MultiIO.new($stdout, File.open(SKYLIGHT_INSTALL_LOG, "a")))
 
 # Handles terminating in the case of a failure. If we have a bug, we do not
 # want to break our customer's deploy, but extconf.rb requires a Makefile to be
@@ -68,7 +69,7 @@ end
 if Platform::OS == "darwin"
   # If the user installs Xcode-only, they have to approve the
   # license or no "xc*" tool will work.
-  if `/usr/bin/xcrun clang 2>&1` =~ /license/ && !$CHILD_STATUS.success?
+  if `/usr/bin/xcrun clang 2>&1` =~ /license/ && !$CHILD_STATUS.success? # rubocop:disable Style/SoleNestedConditional
     fail <<~MESSAGE
       You have not agreed to the Xcode license and so we are unable to build the native agent.
       To resolve this, you can agree to the license by opening Xcode.app or running:
@@ -206,8 +207,8 @@ find_header "skylight_dlopen.h", hdrpath
 fail "could not create Makefile; dlfcn.h missing" unless have_header "dlfcn.h"
 
 # For escaping the GVL
-unless have_func("rb_thread_call_without_gvl", "ruby/thread.h") || have_func("rb_thread_blocking_region")
-  abort "Ruby is unexpectedly missing rb_thread_blocking_region. This should not happen."
+unless have_func("rb_thread_call_without_gvl", "ruby/thread.h")
+  abort "Ruby is unexpectedly missing rb_thread_call_without_gvl. This should not happen."
 end
 
 # Previous comment stated:

data/ext/libskylight.yml

@@ -1,7 +1,6 @@
-version: "4.1.0-46806f5"
+version: "5.0.0-7111415"
 checksums:
-  x86-linux:         "4054632757516aa44e812860601fcb7f21c8c5d412b2d585868b46c7a8e3cae6"
-  x86_64-linux:      "4675694fba4448ba14787551237bd4e388443895d5c9e5d8a71c550eccd203db"
-  x86_64-linux-musl: "7a81880830d0a409a6f0f39ff42f90a1422542b05384e2480ae05515f6b5f831"
-  x86_64-darwin:     "84eef6c330818c2bad1628ff189b9cb88275c9d72a28afac88a0d054d8002230"
-  x86_64-freebsd:    "a86a52203fab4f9a56ad91d5700e14823e6e997b4df1bcb3ae2d9e4296c50b1f"
+  x86-linux:         "c304b73401b82adcbede23886168ca3487ca5901ebeddd6377d8ce758bf9d72d"
+  x86_64-linux:      "4005f06b71295c77dccc7369f313452c7a26fe4c8de1108988e4d06d8f5fb36e"
+  x86_64-linux-musl: "0b8c582f99cc65ef466a506b9f589d634c8b502d4de5991c80c38e9efa812909"
+  x86_64-darwin:     "efbd36e1cbea562ca9b76342cc3e938a6c0c506e7e7e1c0daaafff71da68364e"

data/ext/skylight_native.c

@@ -86,14 +86,6 @@ typedef void* (*blocking_fn_t)(void*);
 #define WITHOUT_GVL(fn, a) \
   rb_thread_call_without_gvl((blocking_fn_t)(fn), (a), 0, 0)
 
-// Ruby 1.9
-#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
-
-typedef VALUE (*blocking_fn_t)(void*);
-#define WITHOUT_GVL(fn, a) \
-  rb_thread_blocking_region((blocking_fn_t)(fn), (a), 0, 0)
-
-
 #endif
 
 
@@ -103,7 +95,6 @@ typedef VALUE (*blocking_fn_t)(void*);
 
 VALUE rb_mSkylight;
 VALUE rb_eNativeError;
-VALUE rb_mCore;
 VALUE rb_mUtil;
 VALUE rb_cClock;
 VALUE rb_cTrace;
@@ -140,7 +131,7 @@ load_libskylight(VALUE klass, VALUE path) {
 
 /*
  *
- * class Skylight::Core::Util::Clock
+ * class Skylight::Util::Clock
  *
  */
 
@@ -152,7 +143,7 @@ clock_high_res_time(VALUE self) {
 
 /*
  *
- * class Skylight::Core::Instrumenter
+ * class Skylight::Instrumenter
  *
  */
 
@@ -243,33 +234,9 @@ instrumenter_submit_trace(VALUE self, VALUE rb_trace) {
   return Qnil;
 }
 
-static VALUE
-instrumenter_track_desc(VALUE self, VALUE rb_endpoint, VALUE rb_desc) {
-  int tracked;
-  sky_instrumenter_t* instrumenter;
-
-  CHECK_TYPE(rb_endpoint, T_STRING);
-  CHECK_TYPE(rb_desc, T_STRING);
-
-  tracked = 0;
-
-  My_Struct(instrumenter, sky_instrumenter_t, no_instrumenter_msg);
-
-  CHECK_FFI(
-      sky_instrumenter_track_desc(instrumenter, STR2BUF(rb_endpoint), STR2BUF(rb_desc), &tracked),
-      "Instrumenter#native_track_desc");
-
-  if (tracked) {
-    return Qtrue;
-  }
-  else {
-    return Qfalse;
-  }
-}
-
 /*
  *
- * class Skylight::Core::Trace
+ * class Skylight::Trace
  *
  */
 
@@ -503,15 +470,31 @@ trace_span_set_description(VALUE self, VALUE span, VALUE desc) {
 
 static VALUE
 trace_span_set_meta(VALUE self, VALUE span, VALUE meta) {
-  UNUSED(self);
-  UNUSED(span);
-  UNUSED(meta);
+  sky_trace_t* trace;
+  VALUE rb_source_location;
+
+  My_Struct(trace, sky_trace_t, consumed_trace_msg);
+
+  CHECK_TYPE(span, T_FIXNUM);
+  CHECK_TYPE(meta, T_HASH);
+
+  rb_source_location = rb_hash_lookup(meta, ID2SYM(rb_intern("source_location")));
+  if (rb_source_location != Qnil) {
+    sky_buf_t source_location;
+
+    CHECK_TYPE(rb_source_location, T_STRING);
+    source_location = STR2BUF(rb_source_location);
+
+    sky_trace_span_add_string_annotation(trace, FIX2UINT(span), 3, source_location);
+  }
+
   return Qnil;
 }
 
 static VALUE
-trace_span_started(VALUE self) {
+trace_span_started(VALUE self, VALUE span) {
   UNUSED(self);
+  UNUSED(span);
   return Qnil;
 }
 
@@ -524,71 +507,14 @@ trace_span_set_exception(VALUE self, VALUE span, VALUE exception, VALUE exceptio
   return Qnil;
 }
 
-static VALUE
-trace_span_get_correlation_header(VALUE self, VALUE span_id) {
-  UNUSED(self);
-  UNUSED(span_id);
-  return Qnil;
-}
-
-static VALUE
-lex_sql(VALUE klass, VALUE rb_sql) {
-  sky_buf_t sql;
-  sky_buf_t title;
-  sky_buf_t statement;
-  uint8_t title_store[128];
-  VALUE rb_statement;
-  VALUE ret;
-
-  UNUSED(klass);
-  CHECK_TYPE(rb_sql, T_STRING);
-
-  sql = STR2BUF(rb_sql);
-  title = (sky_buf_t) {
-    .data = title_store,
-    .len = sizeof(title_store),
-  };
-
-  // The statement cannot be longer than the original sql string
-  rb_statement = rb_str_buf_new(RSTRING_LEN(rb_sql));
-  statement = (sky_buf_t) {
-    .data = RSTRING_PTR(rb_statement),
-    .len = RSTRING_LEN(rb_sql),
-  };
-
-  CHECK_FFI(sky_lex_sql(sql, &title, &statement),
-    "Skylight#lex_sql");
-
-  // Set the statement return
-  rb_str_set_len(rb_statement, statement.len);
-  rb_enc_associate(rb_statement, rb_utf8_encoding());
-
-  ret = rb_ary_new2(2);
-
-  if (title.len > 0) {
-    rb_ary_store(ret, 0, BUF2STR(title));
-  }
-  else {
-    rb_ary_store(ret, 0, Qnil);
-  }
-
-  rb_ary_store(ret, 1, rb_statement);
-
-  return ret;
-}
-
 void Init_skylight_native() {
   rb_mSkylight = rb_define_module("Skylight");
 
   rb_eNativeError = rb_const_get(rb_mSkylight, rb_intern("NativeError"));
 
   rb_define_singleton_method(rb_mSkylight, "load_libskylight", load_libskylight, 1);
-  rb_define_singleton_method(rb_mSkylight, "lex_sql", lex_sql, 1);
-
-  rb_mCore = rb_define_module_under(rb_mSkylight, "Core");
 
-  // FIXME: Don't put these under Core
-  rb_mUtil  = rb_define_module_under(rb_mCore, "Util");
+  rb_mUtil  = rb_define_module_under(rb_mSkylight, "Util");
   rb_cClock = rb_define_class_under(rb_mUtil, "Clock", rb_cObject);
   rb_define_method(rb_cClock, "native_hrtime", clock_high_res_time, 0);
 
@@ -611,12 +537,10 @@ void Init_skylight_native() {
   rb_define_method(rb_cTrace, "native_span_set_meta", trace_span_set_meta, 2);
   rb_define_method(rb_cTrace, "native_span_started", trace_span_started, 1);
   rb_define_method(rb_cTrace, "native_span_set_exception", trace_span_set_exception, 3);
-  rb_define_method(rb_cTrace, "native_span_get_correlation_header", trace_span_get_correlation_header, 1);
 
   rb_cInstrumenter = rb_const_get(rb_mSkylight, rb_intern("Instrumenter"));
   rb_define_singleton_method(rb_cInstrumenter, "native_new", instrumenter_new, 2);
   rb_define_method(rb_cInstrumenter, "native_start", instrumenter_start, 0);
   rb_define_method(rb_cInstrumenter, "native_stop", instrumenter_stop, 0);
   rb_define_method(rb_cInstrumenter, "native_submit_trace", instrumenter_submit_trace, 1);
-  rb_define_method(rb_cInstrumenter, "native_track_desc", instrumenter_track_desc, 2);
 }

data/lib/skylight.rb

@@ -1,36 +1,233 @@
 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/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.
+if defined?(Rails::Railtie)
+  require "skylight/railtie"
+end
+
 module Skylight
   # Used from the CLI
   autoload :CLI, "skylight/cli"
+  # Is this autoload even useful?
+  autoload :Normalizers, "skylight/normalizers"
 
-  # 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
+  extend Util::Logging
 
-  include Core::Instrumentable
+  LOCK = Mutex.new
 
-  def self.instrumenter_class
-    Instrumenter
-  end
+  # @api private
+  TIERS = %w[
+    rack
+    api
+    app
+    view
+    db
+    noise
+    other
+  ].freeze
 
-  def self.config_class
-    Config
-  end
+  # @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 => 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
+
+    # Stop instrumenting
+    def stop!
+      t { "stop!" }
 
-  Core::Probes.add_path(File.expand_path("skylight/probes", __dir__))
+      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 do
+        @shutdown_thread ||= Thread.new { @instrumenter&.shutdown }
+      end
+    end
+  end
 end