stackify-ruby-apm 1.0.1 → 1.1.0

data/lib/stackify_apm/spies/curb/easy.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# Monkey patch for the CurbSpy class for sending & receiving Curb responses.
+#
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class CurbEasySpy
+      attr_accessor :_apm_http_verb
+      def install
+        Curl::Easy.class_eval do
+          singleton_class.send(:alias_method, :perform_without_apm, :perform)
+          singleton_class.send(:alias_method, :http_head_without_apm, :http_head)
+          singleton_class.send(:alias_method, :http_post_without_apm, :http_post)
+          singleton_class.send(:alias_method, :http_put_without_apm, :http_put)
+          singleton_class.send(:alias_method, :http_get_without_apm, :http_get)
+          singleton_class.send(:alias_method, :http_delete_without_apm, :http_delete)
+          def self.perform(*args)
+            req = nil
+            return perform_without_apm(*args) unless StackifyRubyAPM.current_transaction
+            # Data configuration
+            @_apm_http_verb ||= :GET
+            method = @_apm_http_verb
+            uri = args[0].strip
+            name = "#{method} #{uri}"
+            type = "ext.Curb.Easy.#{method}"
+            # Submits HTTP request
+            #
+            req = perform_without_apm(*args)
+            # Builds span context
+            #
+            status_code = req.status.gsub(/^0-9/, '').to_i
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: status_code,
+              METHOD: method
+            )
+            # Creates new span from HTTP result
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+          end
+
+          def self.http_post(*args)
+            req = nil
+            return http_post_without_apm(*args) unless StackifyRubyAPM.current_transaction
+            # Data configuration
+            #
+            @_apm_http_verb = :POST
+            method = @_apm_http_verb
+            uri = args[0].strip
+            name = "#{method} #{uri}"
+            type = "ext.Curb.Easy.#{method}"
+            req = http_post_without_apm(*args)
+            status_code = req.status.gsub(/^0-9/, '').to_i
+
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: status_code,
+              METHOD: method
+            )
+            # Creates new span from HTTP result
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+          end
+
+          def self.http_put(url, data)
+            req = nil
+            return http_put_without_apm(url, data) unless StackifyRubyAPM.current_transaction
+            # Data configuration
+            #
+            @_apm_http_verb = :PUT
+            method = @_apm_http_verb
+            uri = url.strip
+            name = "#{method} #{uri}"
+            type = "ext.Curb.Easy.#{method}"
+            req = http_put_without_apm(url, data)
+            status_code = req.status.gsub(/^0-9/, '').to_i
+
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: status_code,
+              METHOD: method
+            )
+            # Creates new span from HTTP result
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+          end
+
+          def self.http_get(*args)
+            req = nil
+            return http_get_without_apm(*args) unless StackifyRubyAPM.current_transaction
+            # Data configuration
+            #
+            @_apm_http_verb = :GET
+            method = @_apm_http_verb
+            uri = args[0].strip
+            name = "#{method} #{uri}"
+            type = "ext.Curb.Easy.#{method}"
+            req = http_get_without_apm(*args)
+            status_code = req.status.gsub(/^0-9/, '').to_i
+
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: status_code,
+              METHOD: method
+            )
+            # Creates new span from HTTP result
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+          end
+
+          def self.http_delete(*args)
+            req = nil
+            return http_delete_without_apm(*args) unless StackifyRubyAPM.current_transaction
+            # Data configuration
+            #
+            @_apm_http_verb = :DELETE
+            method = @_apm_http_verb
+            uri = args[0].strip
+            name = "#{method} #{uri}"
+            type = "ext.Curb.Easy.#{method}"
+            req = http_delete_without_apm(*args)
+            status_code = req.status.gsub(/^0-9/, '').to_i
+
+            ctx = Span::Context.new(
+              CATEGORY: 'Web External',
+              SUBCATEGORY: 'Execute',
+              URL: uri,
+              STATUS: status_code,
+              METHOD: method
+            )
+            # Creates new span from HTTP result
+            StackifyRubyAPM.span name, type, context: ctx do
+              req
+            end
+          end
+        end
+      end
+    end
+    # Registers CurbSpy spy, go to: /stackify/spies.rb
+    #
+    register 'Curl::Easy', 'curl/easy', CurbEasySpy.new
+  end
+end

data/lib/stackify_apm/spies/curb/multi.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Monkey patch for the CurbSpy class for sending & receiving Curb responses.
+#
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class CurbMultiSpy
+      def install
+        Curl::Multi.class_eval do
+          singleton_class.send(:alias_method, :http_without_apm, :http)
+
+          def self.http(urls_with_config, _multi_options = {}, &blk)
+            return http_without_apm(urls_with_config, _multi_options = {}, &blk) unless StackifyRubyAPM.current_transaction
+            http_without_apm(urls_with_config, _multi_options = {}) do |c, code, method|
+              status_code = code.zero? ? 404 : code
+              method = method.upcase
+              uri = c.url.to_s.strip
+              name = "#{method} #{uri}"
+              type = "ext.Curb.Multi.#{method}"
+
+              ctx = Span::Context.new(
+                CATEGORY: 'Web External',
+                SUBCATEGORY: 'Execute',
+                URL: uri,
+                STATUS: status_code,
+                METHOD: method
+              )
+              # Creates new span from HTTP result
+              StackifyRubyAPM.span name, type, context: ctx do
+                blk.call(c, code, method)
+              end
+            end
+          end
+        end
+      end
+    end
+    # Registers CurbSpy spy, go to: /stackify/spies.rb
+    #
+    register 'Curl::Multi', 'curl/multi', CurbMultiSpy.new
+  end
+end

data/lib/{stackify → stackify_apm}/spies/httpclient.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Monkey patch for the HTTPClient class for sending & receiving HTTP responses.
 #
 
@@ -8,13 +10,15 @@ module StackifyRubyAPM
     class HTTPClientSpy
       def install
         HTTPClient.class_eval do
-          alias request_without_apm request
+          alias_method 'request_without_apm', 'request'
 
           def request(method, uri, *args, &block)
             req = nil
-            unless StackifyRubyAPM.current_transaction
-              return request_without_apm(method, uri, *args, &block)
-            end
+            return request_without_apm(method, uri, *args, &block) unless StackifyRubyAPM.current_transaction
+
+            # unless StackifyRubyAPM.current_transaction
+            #   return request_without_apm(method, uri, *args, &block)
+            # end
 
             # Data configuration
             #
@@ -42,15 +46,13 @@ module StackifyRubyAPM
             StackifyRubyAPM.span name, type, context: ctx do
               req
             end
-
           end
         end
       end
-      # rubocop:enable Metrics/MethodLength
     end
 
-    # Registers HTTPClient spy, go to: /stackify/spies.rb
+    # Registers HTTPClient spy, go to: /stackify_apm/spies.rb
     #
     register 'HTTPClient', 'httpclient', HTTPClientSpy.new
   end
-end
+end

data/lib/{stackify → stackify_apm}/spies/httprb.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # This class monkey patch the http.rb gem with the request method.
 #
@@ -6,23 +8,20 @@ module StackifyRubyAPM
   module Spies
     # @api private
     class HTTPRbSpy
-
       def install
         HTTP::Client.class_eval do
-          alias request_without_apm request
+          alias_method 'request_without_apm', 'request'
 
           # Make HTTP request
-          def request(verb, uri, opts = {})
-            unless StackifyRubyAPM.current_transaction
-              return request_without_apm(verb, uri, opts = {})
-            end
+          def request(verb, uri, _opts = {})
+            return request_without_apm(verb, uri, _opts = {}) unless StackifyRubyAPM.current_transaction
 
             method = verb.upcase
             uri = uri.strip
             name = "#{method} #{uri}"
             type = "ext.httprb.#{method}"
 
-            req = request_without_apm(verb, uri, opts = {})
+            req = request_without_apm(verb, uri, _opts = {})
             ctx = Span::Context.new(
               CATEGORY: 'Web External',
               SUBCATEGORY: 'Execute',
@@ -37,9 +36,8 @@ module StackifyRubyAPM
           end
         end
       end
-      # rubocop:enable Metrics/MethodLength
     end
 
     register 'HTTP::Client', 'http/client', HTTPRbSpy.new
   end
-end
+end

data/lib/{stackify → stackify_apm}/spies/mongo.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # 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.
 #
@@ -45,7 +47,7 @@ module StackifyRubyAPM
           col = nil
           if document
             document.each_with_index do |val, idx|
-              col = val[1] if idx == 0
+              col = val[1] if idx.zero?
             end
           end
 
@@ -53,7 +55,7 @@ module StackifyRubyAPM
           #
           ctx = Span::Context.new(
             CATEGORY: 'MongoDB',
-            MONGODB_COLLECTION: col,
+            MONGODB_COLLECTION: col
           )
 
           # Creates new span from Mongo event
@@ -71,7 +73,7 @@ module StackifyRubyAPM
       end
     end
 
-    # Registers Mongo spy, go to: /stackify/spies.rb
+    # Registers Mongo spy, go to: /stackify_apm/spies.rb
     #
     register 'Mongo', 'mongo', MongoSpy.new
   end

data/lib/{stackify → stackify_apm}/spies/net_http.rb

@@ -1,5 +1,4 @@
 # Monkey patch for the Net::HTTP class for sending & receiving HTTP responses.
-#
 
 module StackifyRubyAPM
   # @api private
@@ -8,7 +7,7 @@ module StackifyRubyAPM
     class NetHTTPSpy
       def install
         Net::HTTP.class_eval do
-          alias request_without_apm request
+          alias_method 'request_without_apm', 'request'
 
           def request(req, body = nil, &block)
             result = nil
@@ -50,9 +49,9 @@ module StackifyRubyAPM
       end
       # rubocop:enable Metrics/MethodLength
     end
-    
-    # Registers Net::HTTP spy, go to: /stackify/spies.rb
+
+    # Registers Net::HTTP spy, go to: /stackify_apm/spies.rb
     #
     register 'Net::HTTP', 'net/http', NetHTTPSpy.new
   end
-end
+end

data/lib/{stackify → stackify_apm}/spies/redis.rb

@@ -1,36 +1,36 @@
+# frozen_string_literal: true
+
 # Monkey patch for Redis.
 #
-
 module StackifyRubyAPM
   # @api private
   module Spies
     # @api private
     class RedisSpy
-
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
       def install
         ::Redis::Client.class_eval do
-          alias call_without_apm call
-      
+          alias_method '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 = ""
-            
+            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("/")
+              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/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
+              redis_key = args[0..1].join('/') if args.length > 1 && !args[1].include?('=')
             end
 
             return call_without_apm(command, &block) if command[0] == :auth
@@ -43,24 +43,25 @@ module StackifyRubyAPM
               COMPONENT_DETAIL: 'Execute',
               THREAD_ID: Thread.current.object_id,
               OPERATION: name
-            }.tap do |hash| 
+            }.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
-
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
     end
 
-    # Registers Redis spy, go to: /stackify/spies.rb
+    # Registers Redis spy, go to: /stackify_apm/spies.rb
     #
     register 'Redis', 'redis', RedisSpy.new
   end
-end
+end

data/lib/stackify_apm/spies/sequel.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+#
+# This class monkey patch the sequel.rb gem with the request method.
+#
+module StackifyRubyAPM
+  # @api private
+  module Spies
+    # @api private
+    class SequelSpy
+      DEFAULT = 'SQL'.freeze
+      TYPE = 'db.sequel.sql'.freeze
+      TABLE_REGEX = %{["'`]?([A-Za-z0-9]+)}.freeze
+      REGEXES = {
+        /^BEGIN/i => 'BEGIN',
+        /^COMMIT/i => 'COMMIT',
+        /^SELECT .* FROM #{TABLE_REGEX}/i => 'SELECT FROM ',
+        /^INSERT INTO #{TABLE_REGEX}/i => 'INSERT INTO ',
+        /^UPDATE #{TABLE_REGEX}/i => 'UPDATE ',
+        /^DELETE FROM #{TABLE_REGEX}/i => 'DELETE FROM '
+      }.freeze
+      FORMAT = '%s%s'.freeze
+
+      def install
+        require 'sequel/database/logging'
+
+        ::Sequel::Database.class_eval do
+          alias_method 'log_connection_yield_without_apm', 'log_connection_yield'
+
+          def log_connection_yield(sql, *args, &block)
+            return log_connection_yield_without_apm(sql, *args, &block) unless StackifyRubyAPM.current_transaction
+
+            name = summarize sql
+            db_adapter = ''
+            db_adapter = args[0].class.to_s.gsub('::Database', '').downcase if args[0]
+
+            context = Span::Context.new(
+              CATEGORY: 'Database',
+              SUBCATEGORY: 'Execute',
+              COMPONENT_CATEGORY: 'DB Query',
+              COMPONENT_DETAIL: 'Execute SQL Query',
+              SQL: sql,
+              PROVIDER: get_profiler(db_adapter)
+            )
+
+            StackifyRubyAPM.span(name, TYPE, context: context, &block)
+          end
+
+          # rubocop:disable Lint/UselessAssignment
+          def summarize(sql)
+            current_sql ||=
+              REGEXES.find do |regex, sig|
+                if (match = sql.match(regex))
+                  break format(FORMAT, sig, match[1] && match[1].gsub(/["']/, ''))
+                end
+              end || DEFAULT
+          end
+          require 'stackify_apm/helper/database_helper'
+        end
+        # rubocop:enable Lint/UselessAssignment
+      end
+    end
+    register 'Sequel', 'sequel', SequelSpy.new
+  end
+end