stackify-ruby-apm 1.0.1 → 1.1.0

data/lib/{stackify → stackify_apm}/context_builder.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
-#
+
 # This class builds the context of the Transaction/Span
 # Context represents the HTTP request information such as headers, cookies, body.
-#
 
 module StackifyRubyAPM
   # @api private
@@ -19,8 +18,6 @@ module StackifyRubyAPM
 
     private
 
-    # rubocop:disable Metrics/AbcSize
-    #
     # Request format and values are assigned to context
     #
     def apply_to_request(context, rack_env)
@@ -36,7 +33,6 @@ module StackifyRubyAPM
 
       context
     end
-    # rubocop:enable Metrics/AbcSize
 
     def get_body(req)
       return req.POST if req.form_data?
@@ -73,6 +69,7 @@ module StackifyRubyAPM
 
     def build_http_version(rack_env)
       return unless (http_version = rack_env['HTTP_VERSION'])
+
       http_version.gsub(%r{HTTP/}, '')
     end
   end

data/lib/{stackify → stackify_apm}/error.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require 'stackify/stacktrace'
-require 'stackify/context'
-require 'stackify/error/exception'
-require 'stackify/error/log'
+require 'stackify_apm/stacktrace'
+require 'stackify_apm/context'
+require 'stackify_apm/error/exception'
+require 'stackify_apm/error/log'
 
 module StackifyRubyAPM
   # @api private
@@ -11,8 +11,9 @@ module StackifyRubyAPM
     def initialize(culprit: nil)
       @id = SecureRandom.uuid
       @culprit = culprit
+      time_now = Time.now
 
-      @timestamp = (Time.now).to_f * 1000
+      @timestamp = time_now.to_f * 1000
       @context = Context.new
 
       @transaction_id = nil
@@ -21,4 +22,4 @@ module StackifyRubyAPM
     attr_accessor :id, :culprit, :exception, :log, :transaction_id, :context
     attr_reader :timestamp
   end
-end
+end

data/lib/stackify_apm/error/exception.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+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_apm/error/log.rb

@@ -0,0 +1,24 @@
+# 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_apm/error_builder.rb

@@ -0,0 +1,61 @@
+# 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)
+
+      add_stacktrace error, :log, backtrace if backtrace
+      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_apm/helper/database_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# get_profiler - It will return the database driver of the Object.
+#
+module DatabaseHelper
+  # return back valid PROVIDER based on driver name passed in
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/PerceivedComplexity
+  def get_profiler(driver)
+    if driver.to_s.empty?
+      'generic'
+    elsif driver.include? 'mysql'
+      'mysql'
+    elsif driver.include? 'postgres'
+      'postgresql'
+    elsif driver.include? 'oci8'
+      'oracle'
+    elsif driver.include? 'db2'
+      'db2'
+    elsif driver.include? 'sqlite'
+      'generic'
+    end
+  end
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/PerceivedComplexity
+end
+include DatabaseHelper

data/lib/{stackify → stackify_apm}/instrumenter.rb

@@ -1,24 +1,23 @@
+# frozen_string_literal: true
+
+require 'stackify_apm/span'
+require 'stackify_apm/transaction'
 #
 # The Instrumenter will build/process the transactions and spans.
 #
-
-require 'stackify/span'
-require 'stackify/transaction'
-
 module StackifyRubyAPM
-   # @api private
-   class Instrumenter
+  # @api private
+  class Instrumenter
     include Log
 
     KEY = :_stackify_transaction_key
-
+    # Transaction Info class
     class TransactionInfo
       def initialize
         self.current = nil
       end
 
       def current
-        # puts '[Instrumenter] [lib/instrumenter.rb] TransactionInfo.current()'
         Thread.current[KEY]
       end
 
@@ -48,20 +47,17 @@ module StackifyRubyAPM
     end
 
     def current_transaction
-       @transaction_info.current
+      @transaction_info.current
     end
 
     def current_transaction=(transaction)
       @transaction_info.current = transaction
     end
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    # 
     # Creates a new transaction or return the currently running
     #
     def transaction(*args)
-      debug "[Instrumenter] transaction(*args)"
+      debug '[Instrumenter] transaction(*args)'
       unless config.instrument
         yield if block_given?
         return
@@ -83,17 +79,14 @@ module StackifyRubyAPM
         self.current_transaction = nil
         transaction.done
       end
-      
-      #puts transaction.inspect
 
       transaction
     end
-    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def span(*args, &block)
       unless current_transaction
         return yield if block_given?
+
         return
       end
 
@@ -114,5 +107,5 @@ module StackifyRubyAPM
         "current_transaction=#{current_transaction.inspect}" \
         '>'
     end
-   end
-end
+  end
+end

data/lib/{stackify → stackify_apm}/logger/log_device.rb

@@ -8,6 +8,20 @@
 module StackifyRubyAPM
   # @api private
   class LogDevice < Logger::LogDevice
+    alias_method 'write_without_apm', 'write'
+    def write(message)
+      if @filename
+        if FileTest.exist?(@filename)
+        else
+          @dev = create_logfile(@filename)
+          File.chmod(0o777, @filename)
+
+          return @dev
+        end
+      end
+      write_without_apm(message)
+    end
+
     def add_log_header(file)
       # Make it only empty.
     end
@@ -21,10 +35,7 @@ module StackifyRubyAPM
       # set a temporary filename that doesn't have the increment prefix and .log format.
       temp_filename = @filename.gsub(/\-(d*\.?\d*).log/, '')
       # set a temporary file increment while stripping the current filename and retain the number
-      txttemp_fileincrement = @filename.gsub(temp_filename,'')
-      txttemp_fileincrement = txttemp_fileincrement.gsub('-','')
-      txttemp_fileincrement = txttemp_fileincrement.gsub('.log','')
-
+      txttemp_fileincrement = @filename.gsub(temp_filename, '').delete('^0-9')
       # convert the string value to integer
       current_fileprefix = txttemp_fileincrement.to_i
       # assign as filename counter
@@ -33,12 +44,12 @@ module StackifyRubyAPM
         filename_counter = current_fileprefix + 1
       else
         ctr_flagger = 0
-        # a loop that check if the number of filenames if exists or not 
-        (1).upto(current_fileprefix) do |i|
+        # a loop that check if the number of filenames if exists or not
+        1.upto(current_fileprefix) do |i|
           temp_oldfile = "#{temp_filename}-#{i}.log"
-          ctr_flagger = ctr_flagger + 1 if FileTest.exist?(temp_oldfile)
+          ctr_flagger += 1 if FileTest.exist?(temp_oldfile)
         end
-        # if the counter is 0 then set the filename counter to 1        
+        # if the counter is 0 then set the filename counter to 1
         filename_counter = 1 if ctr_flagger < 0
       end
 
@@ -47,14 +58,13 @@ module StackifyRubyAPM
       temp_newfilename = "#{temp_filename}-#{filename_counter}.log"
       @filename = temp_newfilename
       @dev = create_logfile(@filename)
+      File.chmod(0o777, @filename)
 
       true
     end
 
     #  This is the monkeypatch of core Logger method where reformats the file name when creating the file log.
     def shift_log_period(period_end)
-      puts "shift_log_period(period_end) mao ni"
-
       suffix = period_end.strftime(@shift_period_suffix)
       age_file = "#{@filename}.#{suffix}"
       if FileTest.exist?(age_file)
@@ -70,10 +80,11 @@ module StackifyRubyAPM
       @dev.close rescue nil
       File.rename(@filename.to_s, age_file)
       @dev = create_logfile(@filename)
+      File.chmod(0o777, @filename)
 
       true
     end
     # rubocop:enable Style/RescueModifier
     # rubocop:enable Lint/RescueWithoutErrorClass
   end
-end
+end

data/lib/{stackify → stackify_apm}/logger/logger_high_version.rb

@@ -28,12 +28,7 @@ module StackifyRubyAPM
                                             shift_period_suffix: shift_period_suffix)
       end
     end
-    require 'stackify/logger/log_device'
-    # rubocop:enable Style/NumericLiterals
-    # rubocop:enable Style/GuardClause
-    # rubocop:enable Metrics/ParameterLists
-    # rubocop:enable Lint/UnusedMethodArgument
-
 
+    require 'stackify_apm/logger/log_device'
   end
 end

data/lib/{stackify → stackify_apm}/logger/logger_lower_version.rb

@@ -23,6 +23,7 @@ module StackifyRubyAPM
                                             shift_size: shift_size)
       end
     end
-    require 'stackify/logger/log_device'
+
+    require 'stackify_apm/logger/log_device'
   end
 end

data/lib/stackify_apm/middleware.rb

@@ -0,0 +1,70 @@
+# 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_apm/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
+  # @api private
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    # This is where the requests are received, built into a transaction, and then submitted
+    #
+    def call(env)
+      begin
+        # if running? && !path_ignored?(env)
+        transaction = build_transaction(env) if running?
+
+        resp = @app.call env
+
+        submit_transaction(transaction, *resp) if transaction
+      rescue InternalError
+        raise # Don't report StackifyRubyAPM errors
+      rescue StandardError
+        transaction.submit('500', status: 500) if transaction
+        raise
+      ensure
+        transaction.release if transaction
+      end
+
+      resp
+    end
+
+    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