skylight-core 4.0.0.alpha4 → 4.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b333f6d3704521099216e030773e068bbae7fb08cdea202b8ffc81e76a0beed
-  data.tar.gz: 00042ab9ca7c24ccba1ea0ebebcbfb664aa78755cfc9d6ae6595f2f7e5754bd4
+  metadata.gz: ab9eed2e498ca4b55dfed12501b36fdea71433e0505a2c34733a0d025b03bbdd
+  data.tar.gz: c5a4eed17eb02f2beb8e0b54e90196429467676a9b79dbff10ecd24d0cd9c31d
 SHA512:
-  metadata.gz: 38a125f7978eb1c05a848a06edaf10ffea2b16227ea474ea0e9a069633ed40029baf8667e569a9664621a486e0bea053011609c9703d634f20ca04489d9aae46
-  data.tar.gz: c53a44d21608de2a245a8b36ef8d7d4b02870723c88dde340d036473803002f2bef202354cafe3e5b040988adc083dceebf4e575508add93d068945dd13f1fd5
+  metadata.gz: 823f266c1a844a4e8424569b34f35afb9b5998c2688b66e299bbc4ad16c335aceffa17d24ed0c38243d89f7b8b16b202f65fdb8d416dc13a830e3505848b86a2
+  data.tar.gz: 6c134666859922615c8083298fd42d7d7b04bbb6d2845ab08071daadb65fcc19aa471361cc197b84ddecb708694b3bebb3d8e35f9f825985348c5eacf4809afe

data/lib/skylight/core/normalizers/active_job/perform.rb

@@ -11,13 +11,14 @@ module Skylight::Core
           adapter_name = normalize_adapter_name(payload[:adapter])
           desc = "{ adapter: '#{adapter_name}', queue: '#{payload[:job].queue_name}' }"
 
-          maybe_set_endpoint(trace, title)
+          maybe_set_endpoint(trace, payload)
 
           [CAT, title, desc]
         end
 
         def normalize_after(trace, _span, _name, payload)
-          return unless config.enable_segments?
+          return unless config.enable_segments? && assign_endpoint?(trace, payload)
+
           trace.segment = payload[:job].queue_name
         end
 
@@ -30,14 +31,29 @@ module Skylight::Core
             "active_job"
           end
 
-          def maybe_set_endpoint(trace, string)
-            trace.endpoint ||= string
+          def maybe_set_endpoint(trace, payload)
+            if assign_endpoint?(trace, payload)
+              trace.endpoint = normalize_title(payload[:job])
+            end
+          end
+
+          def assign_endpoint?(trace, payload)
+            # Always assign the endpoint if it has not yet been assigned by the ActiveJob probe.
+            return true unless trace.endpoint
+            return unless defined?(Skylight::Core::Probes::ActiveJob::Probe::TITLE)
 
             # If a job is called using #perform_now inside a controller action
             # or within another job's #perform method, we do not want this to
             # overwrite the existing endpoint name (unless it is the default from ActiveJob).
-            return unless trace.endpoint == Skylight::Core::Probes::ActiveJob::Probe::TITLE
-            trace.endpoint = string
+            #
+            # If the current endpoint name matches this payload, return true to allow the
+            # segment to be assigned by normalize_after.
+            trace.endpoint == Skylight::Core::Probes::ActiveJob::Probe::TITLE ||
+              trace.endpoint == normalize_title(payload[:job])
+          end
+
+          def normalize_title(job_instance)
+            job_instance.class.to_s
           end
       end
     end

data/lib/skylight/core/probes/action_view.rb

@@ -6,12 +6,20 @@ module Skylight::Core
           ::ActionView::TemplateRenderer.class_eval do
             alias_method :render_with_layout_without_sk, :render_with_layout
 
-            def render_with_layout(path, locals, *args, &block) #:nodoc:
+            def render_with_layout(*args, &block) #:nodoc:
+              path, locals = case args.length
+                             when 2
+                               args
+                             when 3
+                               # Rails > 6.0.0.beta1 prepends an additional `view` argument
+                               args.last(2)
+                             end
+
               layout = nil
 
               if path
                 layout =
-                  if ::ActionView.gem_version >= Gem::Version.new("5.x")
+                  if ::ActionView::VERSION::MAJOR >= 5
                     find_layout(path, locals.keys, [formats.first])
                   else
                     find_layout(path, locals.keys)
@@ -20,10 +28,10 @@ module Skylight::Core
 
               if layout
                 instrument(:template, identifier: layout.identifier) do
-                  render_with_layout_without_sk(path, locals, *args, &block)
+                  render_with_layout_without_sk(*args, &block)
                 end
               else
-                render_with_layout_without_sk(path, locals, *args, &block)
+                render_with_layout_without_sk(*args, &block)
               end
             end
           end

data/lib/skylight/core/version.rb

@@ -1,5 +1,5 @@
 module Skylight
   module Core
-    VERSION = "4.0.0-alpha4".freeze
+    VERSION = "4.0.0-beta".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skylight-core
 version: !ruby/object:Gem::Version
-  version: 4.0.0.alpha4
+  version: 4.0.0.beta
 platform: ruby
 authors:
 - Tilde, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-16 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -244,11 +244,6 @@ files:
 - lib/skylight/core/util/logging.rb
 - lib/skylight/core/util/platform.rb
 - lib/skylight/core/util/proxy.rb
-- lib/skylight/core/vendor/active_support/notifications.rb
-- lib/skylight/core/vendor/active_support/per_thread_registry.rb
-- lib/skylight/core/vendor/thread_safe.rb
-- lib/skylight/core/vendor/thread_safe/non_concurrent_cache_backend.rb
-- lib/skylight/core/vendor/thread_safe/synchronized_cache_backend.rb
 - lib/skylight/core/version.rb
 - lib/skylight/core/vm/gc.rb
 homepage: https://www.skylight.io

data/lib/skylight/core/vendor/active_support/notifications.rb

@@ -1,207 +0,0 @@
-require 'skylight/core/vendor/active_support/notifications/instrumenter'
-require 'skylight/core/vendor/active_support/notifications/fanout'
-require 'skylight/core/vendor/active_support/per_thread_registry'
-
-module ActiveSupport
-  # = Notifications
-  #
-  # <tt>ActiveSupport::Notifications</tt> provides an instrumentation API for
-  # Ruby.
-  #
-  # == Instrumenters
-  #
-  # To instrument an event you just need to do:
-  #
-  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render text: 'Foo'
-  #   end
-  #
-  # That executes the block first and notifies all subscribers once done.
-  #
-  # In the example above +render+ is the name of the event, and the rest is called
-  # the _payload_. The payload is a mechanism that allows instrumenters to pass
-  # extra information to subscribers. Payloads consist of a hash whose contents
-  # are arbitrary and generally depend on the event.
-  #
-  # == Subscribers
-  #
-  # You can consume those events and the information they provide by registering
-  # a subscriber.
-  #
-  #   ActiveSupport::Notifications.subscribe('render') do |name, start, finish, id, payload|
-  #     name    # => String, name of the event (such as 'render' from above)
-  #     start   # => Time, when the instrumented block started execution
-  #     finish  # => Time, when the instrumented block ended execution
-  #     id      # => String, unique ID for this notification
-  #     payload # => Hash, the payload
-  #   end
-  #
-  # For instance, let's store all "render" events in an array:
-  #
-  #   events = []
-  #
-  #   ActiveSupport::Notifications.subscribe('render') do |*args|
-  #     events << ActiveSupport::Notifications::Event.new(*args)
-  #   end
-  #
-  # That code returns right away, you are just subscribing to "render" events.
-  # The block is saved and will be called whenever someone instruments "render":
-  #
-  #   ActiveSupport::Notifications.instrument('render', extra: :information) do
-  #     render text: 'Foo'
-  #   end
-  #
-  #   event = events.first
-  #   event.name      # => "render"
-  #   event.duration  # => 10 (in milliseconds)
-  #   event.payload   # => { extra: :information }
-  #
-  # The block in the <tt>subscribe</tt> call gets the name of the event, start
-  # timestamp, end timestamp, a string with a unique identifier for that event
-  # (something like "535801666f04d0298cd6"), and a hash with the payload, in
-  # that order.
-  #
-  # If an exception happens during that particular instrumentation the payload will
-  # have a key <tt>:exception</tt> with an array of two elements as value: a string with
-  # the name of the exception class, and the exception message.
-  #
-  # As the previous example depicts, the class <tt>ActiveSupport::Notifications::Event</tt>
-  # is able to take the arguments as they come and provide an object-oriented
-  # interface to that data.
-  #
-  # It is also possible to pass an object as the second parameter passed to the
-  # <tt>subscribe</tt> method instead of a block:
-  #
-  #   module ActionController
-  #     class PageRequest
-  #       def call(name, started, finished, unique_id, payload)
-  #         Rails.logger.debug ['notification:', name, started, finished, unique_id, payload].join(' ')
-  #       end
-  #     end
-  #   end
-  #
-  #   ActiveSupport::Notifications.subscribe('process_action.action_controller', ActionController::PageRequest.new)
-  #
-  # resulting in the following output within the logs including a hash with the payload:
-  #
-  #   notification: process_action.action_controller 2012-04-13 01:08:35 +0300 2012-04-13 01:08:35 +0300 af358ed7fab884532ec7 {
-  #      controller: "Devise::SessionsController",
-  #      action: "new",
-  #      params: {"action"=>"new", "controller"=>"devise/sessions"},
-  #      format: :html,
-  #      method: "GET",
-  #      path: "/login/sign_in",
-  #      status: 200,
-  #      view_runtime: 279.3080806732178,
-  #      db_runtime: 40.053
-  #    }
-  #
-  # You can also subscribe to all events whose name matches a certain regexp:
-  #
-  #   ActiveSupport::Notifications.subscribe(/render/) do |*args|
-  #     ...
-  #   end
-  #
-  # and even pass no argument to <tt>subscribe</tt>, in which case you are subscribing
-  # to all events.
-  #
-  # == Temporary Subscriptions
-  #
-  # Sometimes you do not want to subscribe to an event for the entire life of
-  # the application. There are two ways to unsubscribe.
-  #
-  # WARNING: The instrumentation framework is designed for long-running subscribers,
-  # use this feature sparingly because it wipes some internal caches and that has
-  # a negative impact on performance.
-  #
-  # === Subscribe While a Block Runs
-  #
-  # You can subscribe to some event temporarily while some block runs. For
-  # example, in
-  #
-  #   callback = lambda {|*args| ... }
-  #   ActiveSupport::Notifications.subscribed(callback, "sql.active_record") do
-  #     ...
-  #   end
-  #
-  # the callback will be called for all "sql.active_record" events instrumented
-  # during the execution of the block. The callback is unsubscribed automatically
-  # after that.
-  #
-  # === Manual Unsubscription
-  #
-  # The +subscribe+ method returns a subscriber object:
-  #
-  #   subscriber = ActiveSupport::Notifications.subscribe("render") do |*args|
-  #     ...
-  #   end
-  #
-  # To prevent that block from being called anymore, just unsubscribe passing
-  # that reference:
-  #
-  #   ActiveSupport::Notifications.unsubscribe(subscriber)
-  #
-  # == Default Queue
-  #
-  # Notifications ships with a queue implementation that consumes and publish events
-  # to log subscribers in a thread. You can use any queue implementation you want.
-  #
-  module Notifications
-    class << self
-      attr_accessor :notifier
-
-      def publish(name, *args)
-        notifier.publish(name, *args)
-      end
-
-      def instrument(name, payload = {})
-        if notifier.listening?(name)
-          instrumenter.instrument(name, payload) { yield payload if block_given? }
-        else
-          yield payload if block_given?
-        end
-      end
-
-      def subscribe(*args, &block)
-        notifier.subscribe(*args, &block)
-      end
-
-      def subscribed(callback, *args, &block)
-        subscriber = subscribe(*args, &callback)
-        yield
-      ensure
-        unsubscribe(subscriber)
-      end
-
-      def unsubscribe(args)
-        notifier.unsubscribe(args)
-      end
-
-      def instrumenter
-        InstrumentationRegistry.instrumenter_for(notifier)
-      end
-    end
-
-    # This class is a registry which holds all of the +Instrumenter+ objects
-    # in a particular thread local. To access the +Instrumenter+ object for a
-    # particular +notifier+, you can call the following method:
-    #
-    #   InstrumentationRegistry.instrumenter_for(notifier)
-    #
-    # The instrumenters for multiple notifiers are held in a single instance of
-    # this class.
-    class InstrumentationRegistry # :nodoc:
-      extend ActiveSupport::PerThreadRegistry
-
-      def initialize
-        @registry = {}
-      end
-
-      def instrumenter_for(notifier)
-        @registry[notifier] ||= Instrumenter.new(notifier)
-      end
-    end
-
-    self.notifier = Fanout.new
-  end
-end

data/lib/skylight/core/vendor/active_support/per_thread_registry.rb

@@ -1,52 +0,0 @@
-module ActiveSupport
-  # This module is used to encapsulate access to thread local variables.
-  #
-  # Instead of polluting the thread locals namespace:
-  #
-  #   Thread.current[:connection_handler]
-  #
-  # you define a class that extends this module:
-  #
-  #   module ActiveRecord
-  #     class RuntimeRegistry
-  #       extend ActiveSupport::PerThreadRegistry
-  #
-  #       attr_accessor :connection_handler
-  #     end
-  #   end
-  #
-  # and invoke the declared instance accessors as class methods. So
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler = connection_handler
-  #
-  # sets a connection handler local to the current thread, and
-  #
-  #   ActiveRecord::RuntimeRegistry.connection_handler
-  #
-  # returns a connection handler local to the current thread.
-  #
-  # This feature is accomplished by instantiating the class and storing the
-  # instance as a thread local keyed by the class name. In the example above
-  # a key "ActiveRecord::RuntimeRegistry" is stored in <tt>Thread.current</tt>.
-  # The class methods proxy to said thread local instance.
-  #
-  # If the class has an initializer, it must accept no arguments.
-  module PerThreadRegistry
-    protected
-
-      def method_missing(name, *args, &block) # :nodoc:
-        # Caches the method definition as a singleton method of the receiver.
-        define_singleton_method(name) do |*a, &b|
-          per_thread_registry_instance.public_send(name, *a, &b)
-        end
-
-        send(name, *args, &block)
-      end
-
-    private
-
-      def per_thread_registry_instance
-        Thread.current[name] ||= new
-      end
-  end
-end

data/lib/skylight/core/vendor/thread_safe/non_concurrent_cache_backend.rb

@@ -1,133 +0,0 @@
-module ThreadSafe
-  class NonConcurrentCacheBackend
-    # WARNING: all public methods of the class must operate on the @backend directly without calling each other. This is important
-    # because of the SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance reasons.
-    def initialize(options = nil)
-      @backend = {}
-    end
-
-    def [](key)
-      @backend[key]
-    end
-
-    def []=(key, value)
-      @backend[key] = value
-    end
-
-    def compute_if_absent(key)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        stored_value
-      else
-        @backend[key] = yield
-      end
-    end
-
-    def replace_pair(key, old_value, new_value)
-      if pair?(key, old_value)
-        @backend[key] = new_value
-        true
-      else
-        false
-      end
-    end
-
-    def replace_if_exists(key, new_value)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        @backend[key] = new_value
-        stored_value
-      end
-    end
-
-    def compute_if_present(key)
-      if NULL != (stored_value = @backend.fetch(key, NULL))
-        store_computed_value(key, yield(stored_value))
-      end
-    end
-
-    def compute(key)
-      store_computed_value(key, yield(@backend[key]))
-    end
-
-    def merge_pair(key, value)
-      if NULL == (stored_value = @backend.fetch(key, NULL))
-        @backend[key] = value
-      else
-        store_computed_value(key, yield(stored_value))
-      end
-    end
-
-    def get_and_set(key, value)
-      stored_value = @backend[key]
-      @backend[key] = value
-      stored_value
-    end
-
-    def key?(key)
-      @backend.key?(key)
-    end
-
-    def value?(value)
-      @backend.value?(value)
-    end
-
-    def delete(key)
-      @backend.delete(key)
-    end
-
-    def delete_pair(key, value)
-      if pair?(key, value)
-        @backend.delete(key)
-        true
-      else
-        false
-      end
-    end
-
-    def clear
-      @backend.clear
-      self
-    end
-
-    def each_pair
-      dupped_backend.each_pair do |k, v|
-        yield k, v
-      end
-      self
-    end
-
-    def size
-      @backend.size
-    end
-
-    def get_or_default(key, default_value)
-      @backend.fetch(key, default_value)
-    end
-
-    alias_method :_get, :[]
-    alias_method :_set, :[]=
-    private :_get, :_set
-    private
-    def initialize_copy(other)
-      super
-      @backend = {}
-      self
-    end
-
-    def dupped_backend
-      @backend.dup
-    end
-
-    def pair?(key, expected_value)
-      NULL != (stored_value = @backend.fetch(key, NULL)) && expected_value.equal?(stored_value)
-    end
-
-    def store_computed_value(key, new_value)
-      if new_value.nil?
-        @backend.delete(key)
-        nil
-      else
-        @backend[key] = new_value
-      end
-    end
-  end
-end

data/lib/skylight/core/vendor/thread_safe/synchronized_cache_backend.rb

@@ -1,76 +0,0 @@
-module ThreadSafe
-  class SynchronizedCacheBackend < NonConcurrentCacheBackend
-    require 'mutex_m'
-    include Mutex_m
-    # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are not allowed to call each other.
-
-    def [](key)
-      synchronize { super }
-    end
-
-    def []=(key, value)
-      synchronize { super }
-    end
-
-    def compute_if_absent(key)
-      synchronize { super }
-    end
-
-    def compute_if_present(key)
-      synchronize { super }
-    end
-
-    def compute(key)
-      synchronize { super }
-    end
-
-    def merge_pair(key, value)
-      synchronize { super }
-    end
-
-    def replace_pair(key, old_value, new_value)
-      synchronize { super }
-    end
-
-    def replace_if_exists(key, new_value)
-      synchronize { super }
-    end
-
-    def get_and_set(key, value)
-      synchronize { super }
-    end
-
-    def key?(key)
-      synchronize { super }
-    end
-
-    def value?(value)
-      synchronize { super }
-    end
-
-    def delete(key)
-      synchronize { super }
-    end
-
-    def delete_pair(key, value)
-      synchronize { super }
-    end
-
-    def clear
-      synchronize { super }
-    end
-
-    def size
-      synchronize { super }
-    end
-
-    def get_or_default(key, default_value)
-      synchronize { super }
-    end
-
-    private
-    def dupped_backend
-      synchronize { super }
-    end
-  end
-end

data/lib/skylight/core/vendor/thread_safe.rb

@@ -1,126 +0,0 @@
-require 'thread'
-
-module ThreadSafe
-  autoload :NonConcurrentCacheBackend, 'skylight/core/vendor/thread_safe/non_concurrent_cache_backend'
-  autoload :SynchronizedCacheBackend,  'skylight/core/vendor/thread_safe/synchronized_cache_backend'
-
-  ConcurrentCacheBackend = SynchronizedCacheBackend
-
-  class Cache < ConcurrentCacheBackend
-    KEY_ERROR = defined?(KeyError) ? KeyError : IndexError # there is no KeyError in 1.8 mode
-
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
-
-      super(options)
-      @default_proc = block
-    end
-
-    def [](key)
-      if value = super
-        value
-      elsif @default_proc && !key?(key)
-        @default_proc.call(self, key)
-      else
-        value
-      end
-    end
-
-    def fetch(key, default_value = NULL)
-      if NULL != (value = get_or_default(key, NULL))
-        value
-      elsif block_given?
-        yield key
-      elsif NULL != default_value
-        default_value
-      else
-        raise KEY_ERROR, 'key not found'
-      end
-    end
-
-    def put_if_absent(key, value)
-      computed = false
-      result = compute_if_absent(key) do
-        computed = true
-        value
-      end
-      computed ? nil : result
-    end unless method_defined?(:put_if_absent)
-
-    def value?(value)
-      each_value do |v|
-        return true if value.equal?(v)
-      end
-      false
-    end unless method_defined?(:value?)
-
-    def keys
-      arr = []
-      each_pair {|k, v| arr << k}
-      arr
-    end unless method_defined?(:keys)
-
-    def values
-      arr = []
-      each_pair {|k, v| arr << v}
-      arr
-    end unless method_defined?(:values)
-
-    def each_key
-      each_pair {|k, v| yield k}
-    end unless method_defined?(:each_key)
-
-    def each_value
-      each_pair {|k, v| yield v}
-    end unless method_defined?(:each_value)
-
-    def empty?
-      each_pair {|k, v| return false}
-      true
-    end unless method_defined?(:empty?)
-
-    def size
-      count = 0
-      each_pair {|k, v| count += 1}
-      count
-    end unless method_defined?(:size)
-
-    def marshal_dump
-      raise TypeError, "can't dump hash with default proc" if @default_proc
-      h = {}
-      each_pair {|k, v| h[k] = v}
-      h
-    end
-
-    def marshal_load(hash)
-      initialize
-      populate_from(hash)
-    end
-
-    undef :freeze
-
-    private
-    def initialize_copy(other)
-      super
-      populate_from(other)
-    end
-
-    def populate_from(hash)
-      hash.each_pair {|k, v| self[k] = v}
-      self
-    end
-
-    def validate_options_hash!(options)
-      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Fixnum) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Fixnum"
-      end
-      if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
-        raise ArgumentError, ":load_factor must be a number between 0 and 1"
-      end
-    end
-  end
-end