stackify-ruby-apm 0.9.0

data/lib/stackify/subscriber.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+#
+# The Subscriber registers the existing events.
+# This will trigger (together with the Middleware) once there is a web request.
+#
+
+require 'active_support/notifications'
+require 'stackify/normalizers'
+
+module StackifyRubyAPM
+  # @api private
+  class Subscriber
+    include Log
+
+    def initialize(agent)
+      debug '@stackify_ruby [Subscriber] [lib/subscriber.rb] initialize()'
+      debug agent.inspect
+      @agent = agent
+      @normalizers = Normalizers.build(agent.config)
+    end
+
+    def register!
+      unregister! if @subscription
+
+      @subscription =
+        ActiveSupport::Notifications.subscribe(notifications_regex, self)
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe @subscription
+      @subscription = nil
+    end
+
+    # AS::Notifications API
+
+    Notification = Struct.new(:id, :span)
+
+    # [call] Called when the rails version is 3.x
+    def call(name, started, finished, id, payload)
+      return unless (transaction = @agent.current_transaction)
+      debug '@stackify_ruby [Subscriber] [lib/subscriber.rb] call():'
+      debug id
+      debug name
+      debug transaction
+
+      normalized = @normalizers.normalize(transaction, name, payload)
+
+      if started
+        span =
+        if normalized == :skip
+          nil
+        else
+          name, type, context = normalized
+          @agent.span(name, type, context: context)
+        end
+        transaction.notifications << Notification.new(id, span)
+      end
+
+      if finished
+        while (notification = transaction.notifications.pop)
+          next unless notification.id == id
+  
+          if (span = notification.span)
+            span.done
+          end
+          return
+        end
+      end
+    end
+
+    # [start] Called when the rails version is NOT 3.x
+    def start(name, id, payload)
+      return unless (transaction = @agent.current_transaction)
+        debug '@stackify_ruby [Subscriber] [lib/subscriber.rb] start():'
+        debug id
+        debug name
+        debug transaction
+      normalized = @normalizers.normalize(transaction, name, payload)
+
+      span =
+        if normalized == :skip
+          nil
+        else
+          name, type, context = normalized
+          @agent.span(name, type, context: context)
+        end
+
+      transaction.notifications << Notification.new(id, span)
+    end
+
+    # [finish] Called when the rails version is NOT 3.x
+    def finish(_name, id, _payload)
+      # debug "AS::Notification#finish:#{name}:#{id}"
+      debug '@stackify_ruby [Subscriber] [lib/subscriber.rb] finish():'
+      return unless (transaction = @agent.current_transaction)
+
+      while (notification = transaction.notifications.pop)
+        next unless notification.id == id
+
+        if (span = notification.span)
+          span.done
+        end
+        return
+      end
+    end
+
+    private
+
+    def notifications_regex
+      @notifications_regex ||= /(#{@normalizers.keys.join('|')})/
+    end
+  end
+end

data/lib/stackify/trace_logger.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+#
+# This class generates/appends the json log file after every Web Request
+#
+
+require 'stackify/root_info'
+require 'stackify/serializers'
+
+module StackifyRubyAPM
+
+  # @api private
+  class TraceLogger
+    include Log
+
+    def initialize(config)
+      @config = config
+      @trace_file_counter = 0
+      @process_id = 0
+      @transaction_serializers = Serializers::Transactions.new(config)
+    end
+
+    attr_accessor :trace_file_counter, :process_id
+
+    def post(transactions = [])
+
+      # convert transactions to json
+      json_traces = []
+      transactions.each  do |transaction|
+        # convert transaction to json
+        json_transaction = @transaction_serializers.build(@config, transaction).to_json
+
+        # add to json traces array
+        json_traces.push(json_transaction)
+      end
+
+      pid = $PID || Process.pid
+      host_name = @config.hostname || `hostname`
+      date_now = Time.now
+      current_time = date_now.strftime("%Y-%m-%d, %H:%M:%S.%6N")
+      trace_path = @config.log_trace_path
+      trace_file_result = @config.check_lastlog_needs_new(trace_path)
+      current_trace_file = trace_file_result['latest_file']
+
+      if trace_file_result['new_flagger'] == true
+        @trace_file_counter = @trace_file_counter + 1
+        file_ctr = @trace_file_counter
+        current_trace_file = trace_path + host_name + "#" + pid.to_s + "-" + file_ctr.to_s + ".log"
+      else
+        if @process_id != pid
+          @trace_file_counter = 1
+          @process_id = pid
+          file_ctr = @trace_file_counter
+          current_trace_file = trace_path + host_name + "#" + pid.to_s + "-" + file_ctr.to_s + ".log"
+        end
+      end
+
+      current_trace_file = current_trace_file.gsub(/[[:space:]]/, '')
+      open(current_trace_file, 'a') {|f|
+        json_traces.each do |json_trace|
+          f.puts current_time + "> " + json_trace + "\n"
+        end
+      }
+
+    end
+  end
+end

data/lib/stackify/transaction.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+#
+# This class creates and initializes a new transaction.
+#
+
+module StackifyRubyAPM
+    require 'securerandom'
+    # @api private
+    class Transaction
+        DEFAULT_TYPE = 'custom'.freeze
+
+        # rubocop:disable Metrics/MethodLength
+        def initialize  instrumenter, name = nil, type = nil, context: nil
+          # puts "Loads transaction new initialize  instrumenter, name = nil, type = nil, context: nil"
+          @id = SecureRandom.uuid
+          @instrumenter = instrumenter
+          @name = name
+          @type = type || DEFAULT_TYPE
+          @timestamp = (Time.now).to_f * 1000
+
+          @spans = []
+          @span_id_ticker = -1
+          @dropped_spans = 0
+
+          @notifications = [] # for AS::Notifications
+          @context = context || Context.new
+
+          yield self if block_given?
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        attr_accessor :name, :type, :http_status
+        attr_reader :id, :context, :duration, :dropped_spans,
+            :timestamp, :spans, :result, :notifications, :instrumenter
+
+        def release
+          @instrumenter.current_transaction = nil
+        end
+
+        def done result = nil
+          @duration = (Time.now).to_f * 1000
+          @result = result
+          @http_status = result
+
+          self
+        end
+
+        def done?
+          !!@duration
+        end
+
+        def submit result = nil, status: nil, headers: {}
+          done result unless duration
+          if status
+            context.response = Context::Response.new(status, headers: headers)
+          end
+
+          release
+          @instrumenter.submit_transaction self
+
+          self
+        end
+        # rubocop:disable Metrics/MethodLength
+        def span name, type = nil, backtrace: nil, context: nil
+          span = build_and_start_span(name, type, context, backtrace)
+          return span unless block_given?
+
+          begin
+            result = yield span
+          ensure
+            span.done
+          end
+
+          result
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def current_span
+          spans.reverse.lazy.find(&:running?)
+        end
+
+        def inspect
+          "<StackifyRubyAPM::Transaction id:#{id}" \
+          " name:#{name.inspect}" \
+          " type:#{type.inspect}" \
+          '>'
+        end
+
+        private
+
+        def next_span_id
+          @span_id_ticker += 1
+        end
+
+        def next_span name, type, context
+          Span.new(
+            self,
+            next_span_id,
+            name,
+            type,
+            parent_id: current_span.nil? ? -1 : current_span.id,
+            context: context,
+            http_status: @http_status
+          )
+        end
+
+        def span_frames_min_duration?
+          @instrumenter.agent.config.span_frames_min_duration != 0
+        end
+
+        def build_and_start_span name, type, context, backtrace
+          span = next_span(name, type, context)
+          spans << span
+
+          if backtrace && span_frames_min_duration?
+            span.original_backtrace = backtrace
+          end
+
+          span.start
+        end
+
+    end
+end

data/lib/stackify/util.rb

@@ -0,0 +1,23 @@
+# This module utilizes or handles the time usage or duration of transaction
+module StackifyRubyAPM
+  # @api private
+  module Util
+    def self.nearest_minute(target = Time.now.utc)
+      target - target.to_i % 60
+    end
+
+    def self.micros(target = Time.now.utc)
+      target.to_i * 1_000_000 + target.usec
+    end
+
+    def self.inspect_transaction(transaction)
+      Inspector.new.transaction transaction
+    end
+
+    def self.git_sha
+      sha = `git rev-parse --verify HEAD 2>&1`.chomp
+      $? && $?.success? ? sha : nil # rubocop:disable Style/SpecialGlobalVars
+    end
+  end
+end
+require 'stackify/util/inspector'

data/lib/stackify/util/dig.rb

@@ -0,0 +1,31 @@
+# Backport Enumerable#dig to Ruby < 2.3
+#
+# Implementation from
+#   https://github.com/Invoca/ruby_dig/blob/master/lib/ruby_dig.rb
+
+# @api private
+module RubyDig
+  def dig(key, *rest)
+    value = self[key]
+
+    if value.nil? || rest.empty?
+      value
+    elsif value.respond_to?(:dig)
+      value.dig(*rest)
+    else
+      raise TypeError, "#{value.class} does not respond to `#dig'"
+    end
+  end
+end
+
+if RUBY_VERSION < '2.3'
+  # @api private
+  class Array
+    include RubyDig
+  end
+
+  # @api private
+  class Hash
+    include RubyDig
+  end
+end

data/lib/stackify/util/inflector.rb

@@ -0,0 +1,91 @@
+module StackifyRubyAPM
+  # rubocop:disable all
+  module Util
+    # From https://github.com/rails/rails/blob/v5.2.0/activesupport/lib/active_support/inflector/methods.rb#L254-L332
+    module Inflector
+      extend self
+
+      #
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   constantize('Module')   # => Module
+      #   constantize('Foo::Bar') # => Foo::Bar
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                # => 'inside'
+      #     constantize('C') # => 'outside', same as ::C
+      #   end
+      #
+      # NameError is raised when the name is not in CamelCase or the constant is
+      # unknown.
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split("::".freeze)
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject(constant) do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
+      # Tries to find a constant with the name specified in the argument string.
+      #
+      #   safe_constantize('Module')   # => Module
+      #   safe_constantize('Foo::Bar') # => Foo::Bar
+      #
+      # The name is assumed to be the one of a top-level constant, no matter
+      # whether it starts with "::" or not. No lexical context is taken into
+      # account:
+      #
+      #   C = 'outside'
+      #   module M
+      #     C = 'inside'
+      #     C                     # => 'inside'
+      #     safe_constantize('C') # => 'outside', same as ::C
+      #   end
+      #
+      # +nil+ is returned when the name is not in CamelCase or the constant (or
+      # part of it) is unknown.
+      #
+      #   safe_constantize('blargle')                  # => nil
+      #   safe_constantize('UnknownModule')            # => nil
+      #   safe_constantize('UnknownModule::Foo::Bar')  # => nil
+      def safe_constantize(camel_cased_word)
+        constantize(camel_cased_word)
+      rescue NameError => e
+        raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+                             e.name.to_s == camel_cased_word.to_s)
+      rescue ArgumentError => e
+        raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
+      end
+    end
+  end
+  # rubocop:enable all
+end