stackify-ruby-apm 0.9.0

data/lib/stackify/internal_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  class InternalError < StandardError; end
+end

data/lib/stackify/log.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  # @api private
+  # This module will format the process logs perform between the Agent and Web App
+  module Log
+    PREFIX = '[StackifyRubyAPM] '.freeze
+
+    def debug(msg, *args, &block)
+      log(:debug, msg, *args, &block)
+    end
+
+    def info(msg, *args, &block)
+      log(:info, msg, *args, &block)
+    end
+
+    def warn(msg, *args, &block)
+      log(:warn, msg, *args, &block)
+    end
+
+    def error(msg, *args, &block)
+      log(:error, msg, *args, &block)
+    end
+
+    def fatal(msg, *args, &block)
+      log(:fatal, msg, *args, &block)
+    end
+
+    def log(lvl, msg, *args)
+      return unless logger
+
+      formatted_msg = prepend_prefix(format(msg.to_s, *args))
+
+      return logger.send(lvl, formatted_msg) unless block_given?
+
+      # TODO: dont evaluate block if level is higher
+      logger.send(lvl, "#{formatted_msg}\n#{yield}")
+    end
+
+    private
+
+    def prepend_prefix(str)
+      "#{PREFIX}#{str}"
+    end
+
+    def logger
+      return false unless (config = instance_variable_get(:@config))
+      config.logger
+    end
+  end
+end

data/lib/stackify/logger.rb

@@ -0,0 +1,10 @@
+module StackifyRubyAPM
+  # Starts the Monkey patch for the generated log by not including the header
+  #
+  # @param file
+  # @removed the header of the generated log
+  class Logger::LogDevice
+    def add_log_header(file)
+    end
+  end
+end

data/lib/stackify/middleware.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+#
+# This class monkey patches the Rack Middleware method: e.g., call(env)
+# It also handles the submission of transactions to Agent.
+#
+# If Agent is running, build_transaction(env) is called:
+#
+#   -> BUILDS transaction: /stackify_ruby_apm.rb (#self.transaction)
+#     -> builds a [Context] from a Rack `env`: /stackify_ruby_apm.rb (#self.build_context)
+#     -> context may include information about the request,
+#        response, current user and more
+#
+#   -> SUBMITS transaction: stackify/transaction.rb (#submit)
+#     -> instrumenter submits transaction
+#     -> worker will run (if != running), responsible for sending transactions to APM
+#        for every 10 secs (based on config.flush_interval)
+#     -> transaction will be stored in queue by Agent
+#     -> worker will constantly execute transaction sending to APM 
+#
+
+module StackifyRubyAPM
+
+    class Middleware
+      def initialize(app)
+        # puts "@stackify_ruby [Middleware] [lib/middleware.rb] initialize(app)"
+        @app = app
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+      # This is where the requests are received, built into a transaction, and then submitted
+      #
+      def call(env)
+        begin
+
+        #if running? && !path_ignored?(env)
+        if running?
+          transaction = build_transaction(env)
+        end
+
+        resp = @app.call env
+        # puts "@stackify_ruby [Middleware] [lib/middleware.rb] Loads call(env) in middleware module"
+
+        submit_transaction(transaction, *resp) if transaction
+        rescue InternalError
+        raise # Don't report StackifyRubyAPM errors
+        rescue ::Exception => e
+          #puts "@stackify_ruby [Middleware] [lib/middleware.rb] Error Message: #{e.message}"
+          transaction.submit('500', status: 500) if transaction
+        raise
+        ensure
+         transaction.release if transaction
+        end
+
+        resp
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
+  
+      def submit_transaction(transaction, status, headers, _body)
+        result = status.to_i
+        transaction.submit(result, status: status, headers: headers)
+      end
+
+      # Start of transaction building with params: name, type, context
+      #
+      def build_transaction(env)
+        # puts "@stackify_ruby [Middleware] [lib/middleware.rb] middleware build transaction env"
+        StackifyRubyAPM.transaction 'Rack', 'request', context: StackifyRubyAPM.build_context(env)
+      end
+
+      def running?
+        StackifyRubyAPM.running?
+      end
+
+      def config
+        StackifyRubyAPM.agent.config
+      end
+    end
+end

data/lib/stackify/naively_hashable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+#
+# This module converts its result to a hash.
+#
+
+module StackifyRubyAPM
+  # @api private
+  module NaivelyHashable
+    def naively_hashable?
+      true
+    end
+
+    def to_h
+      instance_variables.each_with_object({}) do |name, h|
+
+        key = name.to_s.delete('@').to_sym
+        value = instance_variable_get(name)
+        is_hashable =
+          value.respond_to?(:naively_hashable?) && value.naively_hashable?
+
+        h[key] = is_hashable ? value.to_h : value
+      end
+    end
+  end
+end

data/lib/stackify/normalizers.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+#
+# Collects and registers existing events and classes 
+#
+
+module StackifyRubyAPM # :nodoc:
+  # @api private
+  module Normalizers
+    # @api privagte
+    class Normalizer
+      def initialize(config)
+        @config = config
+      end
+
+      def self.register(name)
+        Normalizers.register(name, self)
+      end
+    end
+
+    def self.register(name, klass)
+      @registered ||= {}
+      @registered[name] = klass
+    end
+
+    def self.build(config)
+      # puts '@stackify_ruby [Normalizers] [lib/normalizer.rb] self.build(config)'
+      normalizers = @registered.each_with_object({}) do |(name, klass), built|
+        built[name] = klass.new(config)
+      end
+      Collection.new(normalizers)
+    end
+
+    # @api private
+    class Collection
+      # @api private
+      class SkipNormalizer
+        def initialize; end
+
+        def normalize(*_args)
+          :skip
+        end
+      end
+
+      def initialize(normalizers)
+        @normalizers = normalizers
+        @default = SkipNormalizer.new
+      end
+
+      def for(name)
+        @normalizers.fetch(name, @default)
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def normalize(transaction, name, payload)
+        self.for(name).normalize(transaction, name, payload)
+      end
+    end
+  end
+
+  %w[
+    action_controller
+    action_mailer
+    action_view
+    active_record
+  ].each do |lib|
+    require "stackify/normalizers/#{lib}"
+  end
+end

data/lib/stackify/normalizers/action_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  module Normalizers
+    module ActionController
+      # @api private
+      class ProcessActionNormalizer < Normalizer
+        register 'process_action.action_controller'
+        TYPE = 'app.controller.action'.freeze
+
+        def normalize(transaction, _name, payload)
+          transaction.name = endpoint(payload)
+          [transaction.name, TYPE, nil]
+        end
+
+        private
+
+        def endpoint(payload)
+          "#{payload[:controller]}##{payload[:action]}"
+        end
+      end
+    end
+  end
+end

data/lib/stackify/normalizers/action_mailer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  module Normalizers
+    module ActionMailer
+      # @api private
+      class ProcessActionNormalizer < Normalizer
+        register 'process.action_mailer'
+        TYPE = 'app.mailer.action'.freeze
+
+        def normalize(_transaction, _name, payload)
+          [endpoint(payload), TYPE, nil]
+        end
+
+        private
+
+        def endpoint(payload)
+          "#{payload[:mailer]}##{payload[:action]}"
+        end
+      end
+    end
+  end
+end

data/lib/stackify/normalizers/action_view.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  module Normalizers
+    module ActionView
+      # @api private
+      class RenderNormalizer < Normalizer
+        private
+
+        def normalize_render(payload, type)
+          [path_for(payload[:identifier]), type, nil]
+        end
+
+        def path_for(path)
+          return 'Unknown template' unless path
+          return path unless path.start_with?('/')
+
+          view_path(path) || gem_path(path) || 'Absolute path'
+        end
+
+        def view_path(path)
+          root = @config.view_paths.find { |vp| path.start_with?(vp) }
+          return unless root
+
+          strip_root(root, path)
+        end
+
+        def gem_path(path)
+          root = Gem.path.find { |gp| path.start_with? gp }
+          return unless root
+
+          format '$GEM_PATH/%s', strip_root(root, path)
+        end
+
+        def strip_root(root, path)
+          start = root.length + 1
+          path[start, path.length]
+        end
+      end
+
+      # @api private
+      class RenderTemplateNormalizer < RenderNormalizer
+        register 'render_template.action_view'
+        TYPE = 'template.view'.freeze
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE)
+        end
+      end
+
+      # @api private
+      class RenderPartialNormalizer < RenderNormalizer
+        register 'render_partial.action_view'
+        TYPE = 'template.view.partial'.freeze
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE)
+        end
+      end
+
+      # @api private
+      class RenderCollectionNormalizer < RenderNormalizer
+        register 'render_collection.action_view'
+        TYPE = 'template.view.collection'.freeze
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, TYPE)
+        end
+      end
+    end
+  end
+end

data/lib/stackify/normalizers/active_record.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  module Normalizers
+    module ActiveRecord
+      # @api private
+      class SqlNormalizer < Normalizer
+        include Log
+        register 'sql.active_record'
+
+        def initialize(*args)
+          super(*args)
+
+          @type = format('db.%s.sql', lookup_adapter || 'unknown').freeze
+        end
+
+        def normalize(_transaction, _name, payload)
+          return :skip if %w[SCHEMA CACHE].include?(payload[:name])
+
+          statement = query_variables(payload)
+          name = payload[:sql] || payload[:name] || 'Default'
+          context = Span::Context.new(statement)
+          [name, @type, context]
+        end
+
+        private
+
+        # return back valid PROVIDER based on driver name passed in
+        def get_profiler(driver)
+          if driver.to_s.empty?
+            "generic"
+          elsif driver.include? "mysql"
+            "mysql"
+          elsif driver.include? "pg"
+            "postgresql"
+          elsif driver.include? "oci8"
+            "oracle"
+          elsif driver.include? "db2"
+            "db2"
+          end
+        end
+
+        def query_variables(payload)
+          debug "@stackify_ruby [SqlNormalizer] [normalizers/active_record.rb] query_variables payload:"
+          debug payload.inspect
+
+          if payload[:type_casted_binds]
+            row_id = payload[:type_casted_binds][0]
+          else
+            row_id = []
+          end
+
+          {
+            CATEGORY: 'Database',
+            SUBCATEGORY: 'Execute',
+            COMPONENT_CATEGORY: 'DB Query',
+            COMPONENT_DETAIL: 'Execute SQL Query',
+            SQL: payload[:sql],
+            PROVIDER: get_profiler(lookup_adapter)
+          }
+        end
+
+        def lookup_adapter
+          ::ActiveRecord::Base.connection.adapter_name.downcase
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end