stackify-ruby-apm 0.9.0

data/lib/stackify/context.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+#
+# This class initializes the parameters and variables for the context of Transaction/Span
+#
+
+require 'stackify/context/request'
+require 'stackify/context/request/socket'
+require 'stackify/context/request/url'
+require 'stackify/context/response'
+
+module StackifyRubyAPM
+  # @api private
+  class Context
+    include NaivelyHashable
+
+    attr_accessor :request, :response
+    attr_reader :custom, :tags
+
+    def initialize
+      @custom = {}
+      @tags = {}
+    end
+  end
+end

data/lib/stackify/context/request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  class Context
+    # @api private
+    class Request
+      include NaivelyHashable
+
+      attr_accessor :body, :cookies, :env, :headers, :http_version, :method, :socket, :url
+    end
+  end
+end

data/lib/stackify/context/request/socket.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  # @api private
+  class Context
+    # @api private
+    class Request
+      # @api private
+      class Socket
+        include NaivelyHashable
+
+        def initialize(req)
+          @remote_addr = req.ip
+          @encrypted = req.scheme == 'https'
+        end
+
+        attr_reader :remote_addr, :encrypted
+      end
+    end
+  end
+end

data/lib/stackify/context/request/url.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module StackifyRubyAPM
+  # @api private
+  class Context
+    # @api private
+    class Request
+      # @api private
+      class Url
+        include NaivelyHashable
+
+        SKIPPED_PORTS = {
+          'http' => 80,
+          'https' => 443
+        }.freeze
+
+        def initialize(req)
+          @protocol = req.scheme
+          @hostname = req.host
+          @port = req.port.to_s
+          @pathname = req.path
+          @search = req.query_string
+          @hash = nil
+          @full = build_full_url req
+        end
+
+        attr_reader :protocol, :hostname, :port, :pathname, :search, :hash,
+          :full
+
+        private
+
+        def build_full_url(req)
+          url = "#{req.scheme}://#{req.host}"
+
+          if req.port != SKIPPED_PORTS[req.scheme]
+            url += ":#{req.port}"
+          end
+
+          url + req.fullpath
+        end
+      end
+    end
+  end
+end

data/lib/stackify/context/response.rb

@@ -0,0 +1,24 @@
+# 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 = headers
+        @headers_sent = headers_sent
+        @finished = finished
+      end
+
+      attr_accessor :status_code, :headers, :headers_sent, :finished
+    end
+  end
+end

data/lib/stackify/context_builder.rb

@@ -0,0 +1,81 @@
+# 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
+  class ContextBuilder
+    def initialize(_agent); end
+
+    # Creates context
+    #
+    def build(rack_env)
+      # puts "@stackify_ruby [lib/context_builder.rb] Loading ContextBuilder build(rack_env)"
+      context = Context.new
+      apply_to_request(context, rack_env)
+      context
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize
+    #
+    # Request format and values are assigned to context
+    #
+    def apply_to_request(context, rack_env)
+      # puts "@stackify_ruby [lib/context_builder.rb] Loading ContextBuilder apply_to_request(context, rack_env)"
+      req = rails_req?(rack_env) ? rack_env : Rack::Request.new(rack_env)
+      context.request = Context::Request.new unless context.request
+      request = context.request
+      request.socket = Context::Request::Socket.new(req).to_h
+      request.http_version = build_http_version rack_env
+      request.method = req.request_method
+      request.url = Context::Request::Url.new(req).to_h
+      request.headers, request.env = get_headers_and_env(rack_env)
+      request.body = get_body(req)
+
+      context
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def get_body(req)
+      return req.POST if req.form_data?
+
+      body = req.body.read
+      req.body.rewind
+      body
+    end
+
+    def rails_req?(env)
+      defined?(ActionDispatch::Request) &&
+        env.is_a?(ActionDispatch::Request)
+    end
+
+    def get_headers_and_env(rack_env)
+      # In Rails < 5 ActionDispatch::Request inherits from Hash
+      headers =
+        rack_env.respond_to?(:headers) ? rack_env.headers : rack_env
+
+      headers.each_with_object([{}, {}]) do |(key, value), (http, env)|
+        next unless key == key.upcase
+
+        if key.start_with?('HTTP_')
+          http[camel_key(key)] = value
+        else
+          env[key] = value
+        end
+      end
+    end
+
+    def camel_key(key)
+      key.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+    end
+
+    def build_http_version(rack_env)
+      return unless (http_version = rack_env['HTTP_VERSION'])
+      http_version.gsub(%r{HTTP/}, '')
+    end
+  end
+end

data/lib/stackify/error.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'stackify/stacktrace'
+require 'stackify/context'
+require 'stackify/error/exception'
+require 'stackify/error/log'
+
+module StackifyRubyAPM
+  # @api private
+  class Error
+    def initialize(culprit: nil)
+      @id = SecureRandom.uuid
+      @culprit = culprit
+
+      @timestamp = Util.micros
+      @context = Context.new
+
+      @transaction_id = nil
+    end
+
+    attr_accessor :id, :culprit, :exception, :log, :transaction_id, :context
+    attr_reader :timestamp
+  end
+end

data/lib/stackify/error/exception.rb

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

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

@@ -0,0 +1,65 @@
+# 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, type: :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/instrumenter.rb

@@ -0,0 +1,118 @@
+#
+# The Instrumenter will build/process the transactions and spans.
+#
+
+require 'stackify/span'
+require 'stackify/transaction'
+
+module StackifyRubyAPM
+   # @api private
+   class Instrumenter
+    include Log
+
+    KEY = :_stackify_transaction_key
+
+    class TransactionInfo
+      def initialize
+        self.current = nil
+      end
+
+      def current
+        # puts '@stackify_ruby [Instrumenter] [lib/instrumenter.rb] TransactionInfo.current()'
+        Thread.current[KEY]
+      end
+
+      def current=(transaction)
+        Thread.current[KEY] = transaction
+      end
+    end
+
+    def initialize(agent)
+      debug '@stackify_ruby [Instrumenter] [lib/instrumenter.rb] initialize()'
+      @agent = agent
+      @config = agent.config
+
+      @transaction_info = TransactionInfo.new
+    end
+
+    attr_reader :agent, :config, :pending_transactions
+
+    def stop
+      current_transaction.release if current_transaction
+      @subscriber.unregister! if @subscriber
+    end
+
+    def subscriber=(subscriber)
+      @subscriber = subscriber
+      @subscriber.register!
+    end
+
+    def current_transaction
+       @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 function transaction(*args)"
+      unless config.instrument
+        yield if block_given?
+        return
+      end
+
+      if (transaction = current_transaction)
+        yield transaction if block_given?
+        return transaction
+      end
+
+      transaction = Transaction.new self, *args
+
+      self.current_transaction = transaction
+      return transaction unless block_given?
+
+      begin
+        yield transaction
+      ensure
+        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
+
+      current_transaction.span(*args, &block)
+    end
+
+    # Once the transaction is submitted it will be stored temporarily in queue
+    #
+    def submit_transaction(transaction)
+      debug '@stackify_ruby [Instrumenter] [lib/instrumenter.rb] submit_transaction(transaction):'
+      debug transaction.inspect
+      agent.enqueue_transaction transaction
+      return unless config.debug_transactions
+    end
+
+    def inspect
+      '<StackifyRubyAPM::Instrumenter ' \
+        "current_transaction=#{current_transaction.inspect}" \
+        '>'
+    end
+   end
+end