stackify-ruby-apm 0.9.0 → 1.0.0

data/lib/stackify/normalizers/active_record.rb

@@ -37,11 +37,13 @@ module StackifyRubyAPM
             "oracle"
           elsif driver.include? "db2"
             "db2"
+          elsif driver.include? "sqlite"
+            "sqlite"
           end
         end
 
         def query_variables(payload)
-          debug "@stackify_ruby [SqlNormalizer] [normalizers/active_record.rb] query_variables payload:"
+          debug "[SqlNormalizer] query_variables payload:"
           debug payload.inspect
 
           if payload[:type_casted_binds]

data/lib/stackify/railtie.rb

@@ -24,7 +24,6 @@ module StackifyRubyAPM
     # 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?('/')

data/lib/stackify/serializers/errors.rb

@@ -10,14 +10,15 @@ module StackifyRubyAPM
       def build(error)
 
         if (exception = error.exception)
+          current_timestamp = error.timestamp
 
-         base = {
-          CaughtBy: exception.module,  
-          Exception: exception.type,
-          Message: exception.message,
-          Timestamp:  micros_to_time(error.timestamp).utc.iso8601(3),
-          Frames: exception.stacktrace.to_a, 
-         }
+          base = {
+            CaughtBy: exception.module,  
+            Exception: exception.type,
+            Message: exception.message,
+            Timestamp: "#{current_timestamp.round}",
+            Frames: exception.stacktrace.to_a, 
+          }
          
         end
 

data/lib/stackify/serializers/transactions.rb

@@ -17,7 +17,9 @@ module StackifyRubyAPM
           call: transaction.name,
           reqBegin: transaction.timestamp,
           reqEnd: transaction.duration,
-          props: RootInfo.build(config, transaction)
+          props: RootInfo.build(config, transaction),
+          exceptions: transaction.exceptions,
+          stacks: []
         }
 
         # serialize all the spans
@@ -27,7 +29,6 @@ module StackifyRubyAPM
         end
 
         add_children_spans(root_span_json, children_spans_json)
-
         root_span_json
       end
 

data/lib/stackify/span.rb

@@ -27,7 +27,6 @@ module StackifyRubyAPM
       @parent_id = parent_id
       @context = context
       @http_status = http_status
-
       @stacktrace = nil
       @original_backtrace = nil
     end
@@ -68,4 +67,4 @@ module StackifyRubyAPM
     private
 
   end
-end
+end

data/lib/stackify/span/context.rb

@@ -20,7 +20,11 @@ module StackifyRubyAPM
                     :METHOD,
                     :URL,
                     :STATUS,
-                    :PROVIDER
+                    :PROVIDER,
+                    :OPERATION,
+                    :CACHEKEY,
+                    :CACHENAME,
+                    :THREAD_ID
     end
   end
 end

data/lib/stackify/spies/action_dispatch.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
-# This module monkey patches usually in Exceptions class
+#
+# Monkey patch for the ActionDispatch::ShowExceptions class which handles exception events.
+#
+
 module StackifyRubyAPM
   # @api private
   module Spies
@@ -10,6 +13,8 @@ module StackifyRubyAPM
           alias render_exception_without_apm render_exception
 
           def render_exception(env, exception)
+            # Creates exception log report
+            #
             StackifyRubyAPM.report(exception)
             render_exception_without_apm env, exception
           end
@@ -17,6 +22,8 @@ module StackifyRubyAPM
       end
     end
 
+    # Registers ActionDispatch spy, go to: /stackify/spies.rb
+    #
     register(
       'ActionDispatch::ShowExceptions',
       'action_dispatch/show_exception',

data/lib/stackify/spies/httpclient.rb

@@ -1,14 +1,11 @@
-require 'stackify/log'
-require 'stackify/logger'
+# Monkey patch for the HTTPClient class for sending & receiving HTTP responses.
+#
 
 module StackifyRubyAPM
   # @api private
   module Spies
     # @api private
     class HTTPClientSpy
-      include Log
-
-      # This class monkeypatches the HTTPClient class with request method.
       def install
         HTTPClient.class_eval do
           alias request_without_apm request
@@ -18,12 +15,20 @@ module StackifyRubyAPM
             unless StackifyRubyAPM.current_transaction
               return request_without_apm(method, uri, *args, &block)
             end
+
+            # Data configuration
+            #
             method = method.upcase
             uri = uri.strip
             name = "#{method} #{uri}"
             type = "ext.httpclient.#{method}"
 
+            # Submits HTTP request
+            #
             req = request_without_apm(method, uri, *args, &block)
+
+            # Builds span context
+            #
             ctx = Span::Context.new(
               CATEGORY: 'Web External',
               SUBCATEGORY: 'Execute',
@@ -32,6 +37,8 @@ module StackifyRubyAPM
               METHOD: method
             )
 
+            # Creates new span from HTTP result
+            #
             StackifyRubyAPM.span name, type, context: ctx do
               req
             end
@@ -42,6 +49,8 @@ module StackifyRubyAPM
       # rubocop:enable Metrics/MethodLength
     end
 
+    # Registers HTTPClient spy, go to: /stackify/spies.rb
+    #
     register 'HTTPClient', 'httpclient', HTTPClientSpy.new
   end
 end

data/lib/stackify/spies/httprb.rb

@@ -0,0 +1,45 @@
+#
+# This class monkey patch the http.rb gem with the request method.
+#
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class HTTPRbSpy
+
+      def install
+        HTTP::Client.class_eval do
+          alias request_without_apm request
+
+          # Make HTTP request
+          def request(verb, uri, opts = {})
+            unless StackifyRubyAPM.current_transaction
+              return request_without_apm(verb, uri, opts = {})
+            end
+
+            method = verb.upcase
+            uri = uri.strip
+            name = "#{method} #{uri}"
+            type = "ext.httprb.#{method}"
+
+            req = request_without_apm(verb, uri, opts = {})
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: req.code,
+              METHOD: method
+            )
+
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'HTTP::Client', 'http/client', HTTPRbSpy.new
+  end
+end

data/lib/stackify/spies/mongo.rb

@@ -1,8 +1,11 @@
+# Monkey patch for the Mongo::Monitoring::Global module in mongoDB(http://api.mongodb.com/ruby/current/Mongo/Monitoring/Global.html)
+# -> Allows subscribing to events for all Mongo clients.
+#
+
 module StackifyRubyAPM
   # @api private
   module Spies
     # @api private
-    # This class monkeypatch the Mongo::Monitoring::Global module in mongoDB(http://api.mongodb.com/ruby/current/Mongo/Monitoring/Global.html)
     class MongoSpy
       def install
         ::Mongo::Monitoring::Global.subscribe(
@@ -36,6 +39,8 @@ module StackifyRubyAPM
         def push_event(event)
           return unless StackifyRubyAPM.current_transaction
 
+          # Fetches collection name from Mongo event
+          #
           document = event.command.find
           col = nil
           if document
@@ -44,10 +49,15 @@ module StackifyRubyAPM
             end
           end
 
+          # Builds span context
+          #
           ctx = Span::Context.new(
             CATEGORY: 'MongoDB',
             MONGODB_COLLECTION: col,
           )
+
+          # Creates new span from Mongo event
+          #
           span = StackifyRubyAPM.span(event.command_name, TYPE, context: ctx)
           @events[event.operation_id] = span
         end
@@ -61,6 +71,8 @@ module StackifyRubyAPM
       end
     end
 
+    # Registers Mongo spy, go to: /stackify/spies.rb
+    #
     register 'Mongo', 'mongo', MongoSpy.new
   end
 end

data/lib/stackify/spies/net_http.rb

@@ -1,9 +1,11 @@
+# Monkey patch for the Net::HTTP class for sending & receiving HTTP responses.
+#
+
 module StackifyRubyAPM
   # @api private
   module Spies
     # @api private
     class NetHTTPSpy
-      # This class monkeypatch the Net::HTTP class with request method.
       def install
         Net::HTTP.class_eval do
           alias request_without_apm request
@@ -14,6 +16,8 @@ module StackifyRubyAPM
               request_without_apm(req, body, &block)
             end
 
+            # Data configuration
+            #
             host, = req['host'] && req['host'].split(':')
             method = req.method
 
@@ -22,16 +26,22 @@ module StackifyRubyAPM
             name = "#{method} #{host}"
             type = "ext.net_http.#{method}"
 
+            # Submits HTTP request
+            #
             result = request_without_apm(req, body, &block)
 
+            # Builds span context
+            #
             ctx = Span::Context.new(
               CATEGORY: 'Web External',
               SUBCATEGORY: 'Execute',
-              URL: req.uri,
+              URL: req.uri.nil? ? host : req.uri,
               STATUS: result.code.to_i,
               METHOD: method
             )
 
+            # Creates new span from HTTP result
+            #
             StackifyRubyAPM.span name, type, context: ctx do
               return result
             end
@@ -41,7 +51,8 @@ module StackifyRubyAPM
       # rubocop:enable Metrics/MethodLength
     end
     
-
+    # Registers Net::HTTP spy, go to: /stackify/spies.rb
+    #
     register 'Net::HTTP', 'net/http', NetHTTPSpy.new
   end
 end

data/lib/stackify/spies/redis.rb

@@ -0,0 +1,66 @@
+# Monkey patch for Redis.
+#
+
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class RedisSpy
+
+      def install
+        ::Redis::Client.class_eval do
+          alias call_without_apm call
+      
+          def call(command, &block)
+            name = command[0].upcase.to_s
+            type = 'db.redis'
+            redis_details = command[1].is_a?(String) ? command[1].split(":") : []
+            redis_nspace = !redis_details.blank? ? redis_details[0] : ""
+            redis_key = ""
+            
+            # Checks CACHEKEY value
+            if !redis_details.blank? && redis_details[1]
+              # Initially sets the CACHEKEY value
+              args = redis_details[1].split("/")
+              redis_key = args[0]
+
+              # If command has passed __method__, it will be included in the CACHEKEY value
+              # Possible formats:
+              # `<namespace:key/method_name/expires_in=300/ttl=60/>` 
+              # `<namespace:key/expires_in=300/ttl=60/>`
+              if args.length > 1 && !args[1].include?("=")
+                redis_key = args[0..1].join("/")
+              end
+            end
+
+            return call_without_apm(command, &block) if command[0] == :auth
+
+            context = {
+              PROVIDER: 'Redis',
+              CATEGORY: 'Cache',
+              SUBCATEGORY: 'Execute',
+              COMPONENT_CATEGORY: 'Cache',
+              COMPONENT_DETAIL: 'Execute',
+              THREAD_ID: Thread.current.object_id,
+              OPERATION: name
+            }.tap do |hash| 
+              hash[:CACHEKEY] = redis_key unless redis_key.empty?
+              hash[:CACHENAME] = redis_nspace unless redis_nspace.empty?
+            end
+
+            ctx = Span::Context.new(context)
+      
+            StackifyRubyAPM.span name, type, context: ctx do
+              call_without_apm(command, &block)
+            end
+          end
+        end
+      end
+
+    end
+
+    # Registers Redis spy, go to: /stackify/spies.rb
+    #
+    register 'Redis', 'redis', RedisSpy.new
+  end
+end

data/lib/stackify/spies/sinatra.rb

@@ -25,7 +25,7 @@ module StackifyRubyAPM
             end
           end
 
-          # Tilt engine templating 
+          # Tilt engine template 
           #
           def compile_template(engine, data, opts, *args, &block)
             opts[:__stackify_apm_template_name] =
@@ -45,6 +45,8 @@ module StackifyRubyAPM
     #
     register 'Sinatra::Base', 'sinatra/base', SinatraSpy.new
 
+    # Tilt template helper & span creator
+    #
     require 'stackify/spies/tilt'
   end
 end

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

@@ -0,0 +1,177 @@
+# 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