stackify-ruby-apm 0.9.0

data/lib/stackify/railtie.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+#
+# This class loads the specified config of the Rails app and starts the Agent.
+#
+# APM Config setting is done at stackify/config.rb
+#
+# After the Agent has been started:
+#   -> the enabled Spies (libraries) are registered
+#   -> the Subscriber is called to register the events
+#   -> the Middleware is then inserted
+#
+
+require 'stackify/subscriber'
+
+module StackifyRubyAPM
+  # @api private
+  # Railtie - core of the Rails framework and provides several hooks to modify the initialization process.
+  class Railtie < Rails::Railtie
+
+    config.stackify = ActiveSupport::OrderedOptions.new
+
+    Config::DEFAULTS.each { |option, value| config.stackify[option] = value }
+
+    # This will overwrite the default values of the config based from stackify_apm.yml initialized
+
+    initializer 'stackify_apm.initialize' do |app|
+      # puts '@stackify_ruby [Railtie] [lib/railtie.rb] initializer'
+      config = app.config.stackify.merge(app: app).tap do |c|
+        # Prepend Rails.root to log_path if present
+        if c.log_path && !c.log_path.start_with?('/')
+          c.log_path = Rails.root.join(c.log_path)
+        end
+      end
+
+      begin
+        agent = StackifyRubyAPM.start config
+        if agent
+          agent.instrumenter.subscriber = StackifyRubyAPM::Subscriber.new(agent)
+          app.middleware.insert 0, Middleware # add a middleware to the application
+        end
+      rescue StandardError => e
+        Rails.logger.error "[Railtie] Failed to start: #{e.message}"
+      end
+    end
+
+    config.after_initialize do
+       require 'stackify/spies/action_dispatch'
+    end
+  end
+end

data/lib/stackify/root_info.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+#
+# This will format the root information of the Transaction.
+#
+
+module StackifyRubyAPM
+  # @api private
+  class RootInfo
+    def initialize(config, transaction)
+      @transaction = transaction
+      @config = config
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Style/StringLiterals
+    def build
+      # get process id
+      pid = $PID || Process.pid
+
+      base = {
+        CATEGORY: 'Ruby',
+        APPLICATION_PATH: '/',
+        APPLICATION_FILESYSTEM_PATH: @config.root_path,
+        APPLICATION_NAME: @config.application_name,
+        APPLICATION_ENV: @config.environment_name,
+        REPORTING_URL: @transaction.name,
+        METHOD: @transaction.context.request.method,
+        STATUS: @transaction.context.response.status_code,
+        URL: @transaction.context.request.url[:full],
+        TRACETYPE: 'WEBAPP',
+        TRACE_ID: @transaction.id,
+        THREAD_ID: Thread.current.object_id,
+        TRACE_SOURCE: 'Ruby',
+        TRACE_TARGET: 'RETRACE',
+        HOST_NAME: @config.hostname || `hostname`,
+        OS_TYPE: 'LINUX',
+        PROCESS_ID: pid,
+        TRACE_VERSION: '2.0'
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def self.build(config, transaction)
+      new(config, transaction).build
+    end
+
+    private
+
+    def runtime
+      case RUBY_ENGINE
+      when 'ruby'
+        { name: RUBY_ENGINE, version: RUBY_VERSION }
+      when 'jruby'
+        { name: RUBY_ENGINE, version: ENV['JRUBY_VERSION'] }
+      end
+    end
+  end
+end

data/lib/stackify/serializers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'json'
+# After the spans are being build it will serialize or rebuild or reformat the spans created into json format
+module StackifyRubyAPM
+  # @api private
+  module Serializers
+    # @api private
+    class Serializer
+      def initialize(config)
+        @config = config
+      end
+
+      private
+
+      def micros_to_time(micros)
+        Time.at(ms(micros) / 1_000)
+      end
+
+      def ms(micros)
+        micros.to_f / 1_000
+      end
+    end
+  end
+end
+
+require 'stackify/serializers/transactions'
+require 'stackify/serializers/errors'

data/lib/stackify/serializers/errors.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+#
+# This module gathers the built Errors and Exceptions into hash formats
+#
+module StackifyRubyAPM
+  module Serializers
+    # @api private
+    class Errors < Serializer
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def build(error)
+
+        if (exception = error.exception)
+
+         base = {
+          CaughtBy: exception.module,  
+          Exception: exception.type,
+          Message: exception.message,
+          Timestamp:  micros_to_time(error.timestamp).utc.iso8601(3),
+          Frames: exception.stacktrace.to_a, 
+         }
+         
+        end
+
+        base
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def build_all(errors)
+        { exceptions: Array(errors).map(&method(:build)) }
+      end
+
+      private
+
+      def build_log(log)
+        {
+          message: log.message,
+          level: log.level,
+          logger_name: log.logger_name,
+          param_message: log.param_message,
+          stacktrace: log.stacktrace.to_a
+        }
+      end
+    end
+  end
+end

data/lib/stackify/serializers/transactions.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+#
+# This class builds and reformats all the gathered spans within the transaction.
+#
+
+module StackifyRubyAPM
+  module Serializers
+    # @api private
+
+    class Transactions < Serializer
+      include Log
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def build(config, transaction)
+
+        root_span_json = {
+          id: -1,
+          call: transaction.name,
+          reqBegin: transaction.timestamp,
+          reqEnd: transaction.duration,
+          props: RootInfo.build(config, transaction)
+        }
+
+        # serialize all the spans
+        children_spans_json = []
+        transaction.spans.each  do |span|
+          children_spans_json.push(build_span(span))
+        end
+
+        add_children_spans(root_span_json, children_spans_json)
+
+        root_span_json
+      end
+
+      private
+
+      # Add Children Spans to span_json
+      def add_children_spans(span_json, children_spans_json)
+        id = span_json[:id]
+        children_spans_json.each  do |child_span_json|
+          parent_id = child_span_json[:parent_id]
+          if parent_id == id
+            child_span_copy = child_span_json.dup
+            add_children_spans(child_span_copy, children_spans_json)
+            if span_json[:stacks].nil?
+              span_json[:stacks] = []
+            end
+            span_json[:stacks].push(child_span_copy)
+          end
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def build_span(span)
+        span_type = span.type
+        span_context = span.context && span.context.to_h
+
+        {
+          id: span.id,
+          parent_id: span.parent_id,
+          call: span_type,
+          reqBegin: span.relative_start,
+          reqEnd: span.relative_end,
+          props: span_context.nil? ? { CATEGORY: 'Ruby' } : span_context,
+          stacks: []
+        }
+      end
+
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/stackify/span.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+#
+# This modules creates and initializes new Span
+#
+
+require 'securerandom'
+require 'stackify/span/context'
+module StackifyRubyAPM
+  # @api private
+  class Span
+    DEFAULT_TYPE = 'custom'.freeze
+
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      transaction,
+      id,
+      name,
+      type = nil,
+      parent_id: nil,
+      context: nil,
+      http_status: nil
+    )
+      @transaction = transaction
+      @id = id
+      @name = name
+      @type = type || DEFAULT_TYPE
+      @parent_id = parent_id
+      @context = context
+      @http_status = http_status
+
+      @stacktrace = nil
+      @original_backtrace = nil
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    attr_accessor :name, :type, :original_backtrace, :http_status
+    attr_reader :id, :context, :stacktrace, :duration, :parent_id, :relative_start, :relative_end
+
+    def start
+      @relative_start = (Time.now).to_f * 1000
+
+      self
+    end
+
+    def done
+      @relative_end = (Time.now).to_f * 1000
+      @duration = (Time.now).to_f * 1000
+      self.original_backtrace = nil # release it
+
+      self
+    end
+
+    def done?
+      !!duration
+    end
+
+    def running?
+      relative_start && !done?
+    end
+
+    def inspect
+      "<StackifyRubyAPM::Span id:#{id}" \
+        " name:#{name.inspect}" \
+        " type:#{type.inspect}" \
+        '>'
+    end
+
+    private
+
+  end
+end

data/lib/stackify/span/context.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module StackifyRubyAPM
+  class Span
+    # @api private
+    class Context
+      include NaivelyHashable
+
+      def initialize(**args)
+        args.each do |key, val|
+          send(:"#{key}=", val)
+        end
+      end
+
+      attr_accessor :CATEGORY,
+                    :SUBCATEGORY,
+                    :COMPONENT_CATEGORY,
+                    :COMPONENT_DETAIL,
+                    :SQL,
+                    :MONGODB_COLLECTION,
+                    :METHOD,
+                    :URL,
+                    :STATUS,
+                    :PROVIDER
+    end
+  end
+end

data/lib/stackify/spies.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+#
+# This module communicates and registers the additional or enabled outside library method
+#
+
+require 'forwardable'
+require 'stackify/util/inflector'
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class Registration
+      extend Forwardable
+
+      def initialize(const_name, require_paths, spy)
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @spy = spy
+      end
+
+      attr_reader :const_name, :require_paths
+
+      def_delegator :@spy, :install
+    end
+
+    def self.require_hooks
+      @require_hooks ||= {}
+    end
+
+    def self.installed
+      @installed ||= {}
+    end
+
+    def self.register(*args)
+      registration = Registration.new(*args)
+
+      if safe_defined?(registration.const_name)
+        registration.install
+        installed[registration.const_name] = registration
+      else
+        register_require_hook registration
+      end
+    end
+
+    def self.register_require_hook(registration)
+      registration.require_paths.each do |path|
+        require_hooks[path] = registration
+      end
+    end
+
+    def self.hook_into(name)
+      return unless (registration = require_hooks[name])
+      return unless safe_defined?(registration.const_name)
+
+      installed[registration.const_name] = registration
+      registration.install
+
+      registration.require_paths.each do |path|
+        require_hooks.delete path
+      end
+    end
+
+    def self.safe_defined?(const_name)
+      Util::Inflector.safe_constantize(const_name)
+    end
+  end
+end
+
+# @api private
+module Kernel
+  private
+
+  alias require_without_apm require
+
+  def require(path)
+    res = require_without_apm(path)
+
+    begin
+      StackifyRubyAPM::Spies.hook_into(path)
+    rescue ::Exception => e
+      puts "Failed hooking into '#{path}'. Please report this at " \
+        'git@bitbucket.org:stackify/stackify-ruby-apm.git'
+      puts e.backtrace.join("\n")
+    end
+
+    res
+  end
+end