stackify-ruby-apm 1.0.1 → 1.1.0

data/lib/stackify/context/response.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module StackifyRubyAPM
-  class Context
-    # @api private
-    class Response
-      include NaivelyHashable
-
-      def initialize(
-        status_code,
-        headers: {},
-        headers_sent: true,
-        finished: true
-      )
-        @status_code = status_code
-        headers = self.make_xstackifyId_header(headers)
-        @headers = headers
-        @headers_sent = headers_sent
-        @finished = finished
-      end
-
-      attr_accessor :status_code, :headers, :headers_sent, :finished
-
-      def make_xstackifyId_header(headers)
-        if (StackifyRubyAPM.agent.current_transaction &&
-          StackifyRubyAPM.agent.current_transaction.id)
-          transaction_id = StackifyRubyAPM.agent.current_transaction.id
-          clientId = StackifyRubyAPM.agent.config.clientId
-          deviceId = StackifyRubyAPM.agent.config.deviceId
-          if clientId && deviceId
-            headers['X-StackifyID'] = "V1|#{transaction_id}|C#{clientId}|CD#{deviceId}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/stackify/error/exception.rb

@@ -1,36 +0,0 @@
-
-module StackifyRubyAPM
-    class Error
-      # @api private
-      class Exception
-        MOD_SPLIT = '::'.freeze
-  
-        def initialize(exception, **attrs)
-          @message =
-            "#{exception.class}: #{exception.message}"
-          @type = exception.class.to_s
-          @module = format_module exception
-  
-          attrs.each do |key, val|
-            send(:"#{key}=", val)
-          end
-        end
-  
-        attr_accessor(
-          :attributes,
-          :code,
-          :handled,
-          :message,
-          :module,
-          :stacktrace,
-          :type
-        )
-  
-        private
-  
-        def format_module(exception)
-          exception.class.to_s.split(MOD_SPLIT)[0...-1].join(MOD_SPLIT)
-        end
-      end
-    end
-  end

data/lib/stackify/error/log.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module StackifyRubyAPM
-    class Error
-      # @api private
-      class Log
-        def initialize(message, attrs = {})
-          @message = message
-  
-          attrs.each do |key, val|
-            send(:"#{key}=", val)
-          end
-        end
-  
-        attr_accessor(
-          :level,
-          :logger_name,
-          :message,
-          :param_message,
-          :stacktrace
-        )
-      end
-    end
-  end
-  

data/lib/stackify/error_builder.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-#
-# This module build errors/exceptions and the Frames/stacktraces affected/related to the error
-#
-module StackifyRubyAPM
-    # @api private
-    class ErrorBuilder
-      def initialize(agent)
-        @agent = agent
-      end
-  
-      def build_exception(exception, handled: true)
-        error = Error.new
-        error.exception = Error::Exception.new(exception, handled: handled)
-  
-        if exception.backtrace
-          add_stacktrace error, :exception, exception.backtrace
-        end
-  
-        add_transaction_id error
-  
-        if (transaction = StackifyRubyAPM.current_transaction)
-          error.context = transaction.context.dup
-        end
-  
-        error
-      end
-  
-      def build_log(message, backtrace: nil, **attrs)
-        error = Error.new
-        error.log = Error::Log.new(message, **attrs)
-  
-        if backtrace
-          add_stacktrace error, :log, backtrace
-        end
-  
-        add_transaction_id error
-  
-        error
-      end
-  
-      private
-  
-      def add_stacktrace(error, kind, backtrace)
-        stacktrace =
-          @agent.stacktrace_builder.build(backtrace, :error)
-        return unless stacktrace
-  
-        case kind
-        when :exception
-          error.exception.stacktrace = stacktrace
-        when :log
-          error.log.stacktrace = stacktrace
-        end
-  
-        error.culprit = stacktrace.frames.first.function
-      end
-  
-      def add_transaction_id(error)
-        return unless (transaction = StackifyRubyAPM.current_transaction)
-        error.transaction_id = transaction.id
-      end
-    end
-  end
-  

data/lib/stackify/middleware.rb

@@ -1,74 +0,0 @@
-# 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)
-        @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
-
-        submit_transaction(transaction, *resp) if transaction
-        rescue InternalError
-        raise # Don't report StackifyRubyAPM errors
-        rescue ::Exception => e
-          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)
-        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/spies/sinatra_activerecord/mysql_adapter.rb

@@ -1,177 +0,0 @@
-# frozen_string_literal: true
-# Spies for active record when sinatra framework is used and active_record is being extended. (mysql adapter)
-#
-module StackifyRubyAPM
-    # @api private
-    module Spies
-      # @api private
-      class MysqlAdapterSpy
-        TYPE = 'db.sinatra_active_record.sql'.freeze
-        if ActiveRecord::VERSION::MAJOR.to_i >= 5
-          # rubocop:disable Metrics/MethodLength
-          def install
-            ActiveRecord::ConnectionAdapters::MySQL::DatabaseStatements.class_eval do
-              alias exec_query_without_apm exec_query
-              alias exec_delete_without_apm exec_delete
-              alias exec_update_without_apm exec_update
-
-              def exec_update(sql, name = nil, binds = [])
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_update_without_apm(sql, name, binds)
-                end
-
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-                result = exec_update_without_apm(sql, name, binds)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-              
-              def exec_delete(sql, name = nil, binds = [])
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_delete_without_apm(sql, name, binds)
-                end
-
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-
-                result = exec_delete_without_apm(sql, name, binds)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-
-              def exec_query(sql, name = "SQL", binds = [], prepare: false)
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_query_without_apm(sql, name, binds)
-                end
-
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-
-                result = exec_query_without_apm(sql, name, binds)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-            end
-          end
-          # rubocop:enable Metrics/MethodLength
-        else
-          # rubocop:disable Metrics/MethodLength
-          def install
-            ActiveRecord::ConnectionAdapters::Mysql2Adapter.class_eval do
-              alias exec_query_without_apm exec_query
-              alias exec_delete_without_apm exec_delete
-              alias exec_update_without_apm exec_update
-              alias exec_insert_without_apm exec_insert
-
-              def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_insert_without_apm(sql, name, binds, pk = nil, sequence_name = nil)
-                end
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-                result = exec_insert_without_apm(sql, name, binds, pk = nil, sequence_name = nil)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-
-              def exec_update(sql, name, binds)
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_update_without_apm(sql, name, binds)
-                end
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-                result = exec_update_without_apm(sql, name, binds)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-
-              def exec_delete(sql, name, binds)
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_delete_without_apm(sql, name, binds)
-                end
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-                result = exec_delete_without_apm(sql, name, binds)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-
-              def exec_query(sql, name = "SQL", binds = [], prepare: false)
-                result = nil
-                unless StackifyRubyAPM.current_transaction
-                  exec_query_without_apm(sql, name, binds)
-                end
-                ctx = Span::Context.new(
-                  CATEGORY: 'Database',
-                  SUBCATEGORY: 'Execute',
-                  COMPONENT_CATEGORY: 'DB Query',
-                  COMPONENT_DETAIL: 'Execute SQL Query',
-                  SQL: sql,
-                  PROVIDER: "mysql"
-                )
-                result = exec_query_without_apm(sql, name, binds)
-                StackifyRubyAPM.span name, TYPE, context: ctx do
-                  return result
-                end
-              end
-            end
-          end
-          # rubocop:enable Metrics/MethodLength
-        end
-      end
-      if ActiveRecord::VERSION::MAJOR.to_i >= 5
-        register 'ActiveRecord::ConnectionAdapters::MySQL::DatabaseStatements', 'active_record/connection_adapters/mysql/database_statements', MysqlAdapterSpy.new
-      else
-        register 'ActiveRecord::ConnectionAdapters::Mysql2Adapter', 'active_record/connection_adapters/mysql2_adapter', MysqlAdapterSpy.new
-      end
-    end
-  end

data/lib/stackify/spies/sinatra_activerecord/postgresql_adapter.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-# Spies for active record when sinatra framework is used and active_record is being extended. (mysql adapter)
-#
-module StackifyRubyAPM
-    # @api private
-    module Spies
-      # @api private
-      class PostgresqlAdapterSpy
-        TYPE = 'db.sinatra_active_record.sql'.freeze
-  
-        # rubocop:disable Metrics/MethodLength
-        def install
-          ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements.class_eval do
-            alias exec_query_without_apm exec_query
-            alias exec_delete_without_apm exec_delete
-            alias exec_update_without_apm exec_update
-            
-            def exec_update(sql, name = nil, binds = [])
-              result = nil
-  
-              unless StackifyRubyAPM.current_transaction
-                exec_update_without_apm(sql, name, binds)
-              end
-  
-              ctx = Span::Context.new(
-                CATEGORY: 'Database',
-                SUBCATEGORY: 'Execute',
-                COMPONENT_CATEGORY: 'DB Query',
-                COMPONENT_DETAIL: 'Execute SQL Query',
-                SQL: sql,
-                PROVIDER: "mysql"
-              )
-              
-              result = exec_update_without_apm(sql, name, binds)
-  
-              StackifyRubyAPM.span name, TYPE, context: ctx do
-                return result
-              end
-            end
-            
-            def exec_delete(sql, name = nil, binds = [])
-              result = nil
-  
-              unless StackifyRubyAPM.current_transaction
-                exec_delete_without_apm(sql, name, binds)
-              end
-  
-              ctx = Span::Context.new(
-                CATEGORY: 'Database',
-                SUBCATEGORY: 'Execute',
-                COMPONENT_CATEGORY: 'DB Query',
-                COMPONENT_DETAIL: 'Execute SQL Query',
-                SQL: sql,
-                PROVIDER: "postgresql"
-              )
-              
-              result = exec_delete_without_apm(sql, name, binds)
-  
-              StackifyRubyAPM.span name, TYPE, context: ctx do
-                return result
-              end
-            end
-            
-            
-            def exec_query(sql, name = "SQL", binds = [], prepare: false)
-              result = nil
-  
-              unless StackifyRubyAPM.current_transaction
-                exec_query_without_apm(sql, name, binds)
-              end
-  
-              ctx = Span::Context.new(
-                CATEGORY: 'Database',
-                SUBCATEGORY: 'Execute',
-                COMPONENT_CATEGORY: 'DB Query',
-                COMPONENT_DETAIL: 'Execute SQL Query',
-                SQL: sql,
-                PROVIDER: "postgresql"
-              )
-              
-              result = exec_query_without_apm(sql, name, binds)
-  
-              StackifyRubyAPM.span name, TYPE, context: ctx do
-                return result
-              end
-            end
-  
-          end
-        end
-        # rubocop:enable Metrics/MethodLength
-      end
-  
-      register 'ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements', 'active_record/connection_adapters/postgresql/database_statements', PostgresqlAdapterSpy.new
-    end
-  end
-