asklytics-influxdb-rails 1.0.0.beta3

data/lib/influxdb/rails/context.rb

@@ -0,0 +1,42 @@
+module InfluxDB
+  module Rails
+    class Context # rubocop:disable Style/Documentation
+      def controller
+        Thread.current[:_influxdb_rails_controller]
+      end
+
+      def controller=(value)
+        Thread.current[:_influxdb_rails_controller] = value
+      end
+
+      def action
+        Thread.current[:_influxdb_rails_action]
+      end
+
+      def action=(value)
+        Thread.current[:_influxdb_rails_action] = value
+      end
+
+      def location
+        [
+          controller,
+          action,
+        ].reject(&:blank?).join("#")
+      end
+
+      def reset
+        Thread.current[:_influxdb_rails_controller] = nil
+        Thread.current[:_influxdb_rails_action] = nil
+        Thread.current[:_influxdb_rails_tags] = nil
+      end
+
+      def tags
+        Thread.current[:_influxdb_rails_tags] || {}
+      end
+
+      def tags=(tags)
+        Thread.current[:_influxdb_rails_tags] = tags
+      end
+    end
+  end
+end

data/lib/influxdb/rails/exception_presenter.rb

@@ -0,0 +1,94 @@
+require "base64"
+require "socket"
+require "json"
+
+module InfluxDB
+  module Rails
+    class ExceptionPresenter # rubocop:disable Style/Documentation
+      attr_reader :exception
+      attr_reader :backtrace
+      attr_reader :params
+      attr_reader :session_data
+      attr_reader :current_user
+      attr_reader :controller
+      attr_reader :action
+      attr_reader :request_url
+      attr_reader :referer
+      attr_reader :remote_ip
+      attr_reader :user_agent
+      attr_reader :custom_data
+
+      def initialize(ex, params = {})
+        ex = ex.continued_exception if ex.respond_to?(:continued_exception)
+        ex = ex.original_exception if ex.respond_to?(:original_exception)
+
+        @exception    = ex.is_a?(String) ? Exception.new(ex) : ex
+        @backtrace    = InfluxDB::Rails::Backtrace.new(@exception.backtrace)
+        @dimensions   = {}
+        configure_from_params(params)
+
+        @environment_variables = ENV.to_hash || {}
+      end
+
+      def context # rubocop:disable Metrics/MethodLength
+        c = {
+          application_name:  InfluxDB::Rails.configuration.application_name,
+          application_root:  InfluxDB::Rails.configuration.application_root,
+          framework:         InfluxDB::Rails.configuration.framework,
+          framework_version: InfluxDB::Rails.configuration.framework_version,
+          language:          "Ruby",
+          language_version:  "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}",
+          custom_data:       @custom_data,
+        }
+
+        InfluxDB::Rails.configuration.add_custom_exception_data(self)
+        c
+      end
+
+      def dimensions
+        {
+          class:    @exception.class.to_s,
+          method:   "#{@controller}##{@action}",
+          filename: File.basename(@backtrace.lines.first.try(:file)),
+          server:   Socket.gethostname,
+          status:   "open",
+        }.merge(@dimensions)
+      end
+
+      def values
+        {
+          exception_message:   @exception.message,
+          exception_backtrace: JSON.generate(@backtrace.to_a),
+        }
+      end
+
+      def request_data
+        {
+          params:       @params,
+          session_data: @session_data,
+          controller:   @controller,
+          action:       @action,
+          request_url:  @request_url,
+          referer:      @referer,
+          remote_ip:    @remote_ip,
+          user_agent:   @user_agent,
+        }
+      end
+
+      private
+
+      def configure_from_params(params)
+        @params       = params[:params]
+        @session_data = params[:session_data] || {}
+        @current_user = params[:current_user]
+        @controller   = params[:controller]
+        @action       = params[:action]
+        @request_url  = params[:request_url]
+        @user_agent   = params[:user_agent]
+        @referer      = params[:referer]
+        @remote_ip    = params[:remote_ip]
+        @custom_data  = params[:custom_data] || {}
+      end
+    end
+  end
+end

data/lib/influxdb/rails/httplog/adapters/ethon.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+if defined?(Ethon)
+  module Ethon
+    class Easy
+      attr_accessor :action_name
+
+      module Http
+        alias orig_http_request http_request
+        def http_request(url, action_name, options = {})
+          @http_log = options.merge(method: action_name) # remember this for compact logging
+          orig_http_request(url, action_name, options)
+        end
+      end
+
+      module Operations
+        alias orig_perform perform
+        def perform
+          return orig_perform unless HttpLog.url_approved?(url)
+
+          bm = Benchmark.realtime { orig_perform }
+
+          # Not sure where the actual status code is stored - so let's
+          # extract it from the response header.
+          encoding = response_headers.scan(/Content-Encoding: (\S+)/).flatten.first
+          content_type = response_headers.scan(/Content-Type: (\S+(; charset=\S+)?)/).flatten.first
+
+          # Hard to believe that Ethon wouldn't parse out the headers into
+          # an array; probably overlooked it. Anyway, let's do it ourselves:
+          headers = response_headers.split(/\r?\n/).drop(1)
+
+          # HttpLog.call(
+          #   method: @http_log[:method],
+          #   url: @url,
+          #   request_body: @http_log[:body],
+          #   request_headers: @http_log[:headers],
+          #   response_code: @return_code,
+          #   response_body: response_body,
+          #   response_headers: headers.map { |header| header.split(/:\s/) }.to_h,
+          #   benchmark: bm,
+          #   encoding: encoding,
+          #   content_type: content_type
+          # )
+
+          HttpLog.save_in_db(
+              method: @http_log[:method],
+              url: @url,
+              request_body: @http_log[:body],
+              request_headers: @http_log[:headers],
+              response_code: @return_code,
+              response_body: response_body,
+              response_headers: headers.map { |header| header.split(/:\s/) }.to_h,
+              benchmark: bm,
+              encoding: encoding,
+              content_type: content_type
+          )
+          return_code
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/httplog/adapters/excon.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+if defined?(Excon)
+  module Excon
+    module HttpLogHelper
+      def httplog_url(datum)
+        @httplog_url ||= ["#{datum[:scheme]}://#{datum[:host]}:#{datum[:port]}#{datum[:path]}", datum[:query]].compact.join('?')
+      end
+    end
+
+    class Socket
+      include Excon::HttpLogHelper
+      alias orig_connect connect
+      def connect
+        host = @data[:proxy] ? @data[:proxy][:host] : @data[:host]
+        port = @data[:proxy] ? @data[:proxy][:port] : @data[:port]
+        HttpLog.log_connection(host, port) if ::HttpLog.url_approved?(httplog_url(@data))
+        orig_connect
+      end
+    end
+
+    class Connection
+      include Excon::HttpLogHelper
+      attr_reader :bm
+
+      alias orig_request request
+      def request(params, &block)
+        result = nil
+        bm = Benchmark.realtime do
+          result = orig_request(params, &block)
+        end
+
+        url = httplog_url(@data)
+        return result unless HttpLog.url_approved?(url)
+
+        headers = result[:headers] || {}
+
+        # HttpLog.call(
+        #   method: params[:method],
+        #   url: url,
+        #   request_body: @data[:body],
+        #   request_headers: @data[:headers] || {},
+        #   response_code: result[:status],
+        #   response_body: result[:body],
+        #   response_headers: headers,
+        #   benchmark: bm,
+        #   encoding: headers['Content-Encoding'],
+        #   content_type: headers['Content-Type']
+        # )
+
+        HttpLog.save_in_db(
+            method: params[:method],
+            url: url,
+            request_body: @data[:body],
+            request_headers: @data[:headers] || {},
+            response_code: result[:status],
+            response_body: result[:body],
+            response_headers: headers,
+            benchmark: bm,
+            encoding: headers['Content-Encoding'],
+            content_type: headers['Content-Type']
+        )
+        result
+      end
+    end
+  end
+end

data/lib/influxdb/rails/httplog/adapters/http.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+if defined?(::HTTP::Client) && defined?(::HTTP::Connection)
+  module ::HTTP # rubocop:disable Style/ClassAndModuleChildren
+    class Client
+      request_method = respond_to?('make_request') ? 'make_request' : 'perform'
+      orig_request_method = "orig_#{request_method}"
+      alias_method(orig_request_method, request_method) unless method_defined?(orig_request_method)
+
+      define_method request_method do |req, options|
+        bm = Benchmark.realtime do
+          @response = send(orig_request_method, req, options)
+        end
+
+        if HttpLog.url_approved?(req.uri)
+          body = if defined?(::HTTP::Request::Body)
+                   req.body.respond_to?(:source) ? req.body.source : req.body.instance_variable_get(:@body)
+                 else
+                   req.body
+                 end
+
+          # HttpLog.call(
+          #   method: req.verb,
+          #   url: req.uri,
+          #   request_body: body,
+          #   request_headers: req.headers,
+          #   response_code: @response.code,
+          #   response_body: @response.body,
+          #   response_headers: @response.headers,
+          #   benchmark: bm,
+          #   encoding: @response.headers['Content-Encoding'],
+          #   content_type: @response.headers['Content-Type']
+          # )
+
+          HttpLog.save_in_db(
+              method: req.verb,
+              url: req.uri,
+              request_body: body,
+              request_headers: req.headers,
+              response_code: @response.code,
+              response_body: @response.body,
+              response_headers: @response.headers,
+              benchmark: bm,
+              encoding: @response.headers['Content-Encoding'],
+              content_type: @response.headers['Content-Type']
+          )
+
+          body.rewind if body.respond_to?(:rewind)
+        end
+
+        @response
+      end
+    end
+
+    class Connection
+      alias orig_initialize initialize unless method_defined?(:orig_initialize)
+
+      def initialize(req, options)
+        HttpLog.log_connection(req.uri.host, req.uri.port) if HttpLog.url_approved?(req.uri)
+        orig_initialize(req, options)
+      end
+    end
+  end
+end

data/lib/influxdb/rails/httplog/adapters/httpclient.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+if defined?(::HTTPClient)
+  class HTTPClient
+    private
+
+    alias orig_do_get_block do_get_block
+
+    def do_get_block(req, proxy, conn, &block)
+      retryable_response = nil
+      bm = Benchmark.realtime do
+        begin
+          orig_do_get_block(req, proxy, conn, &block)
+        rescue RetryableResponse => e
+          retryable_response = e
+        end
+      end
+
+      if HttpLog.url_approved?(req.header.request_uri)
+        res = conn.pop
+
+        # HttpLog.call(
+        #   method: req.header.request_method,
+        #   url: req.header.request_uri,
+        #   request_body: req.body,
+        #   request_headers: req.headers,
+        #   response_code: res.status_code,
+        #   response_body: res.body,
+        #   response_headers: res.headers,
+        #   benchmark: bm,
+        #   encoding: res.headers['Content-Encoding'],
+        #   content_type: res.headers['Content-Type']
+        # )
+
+        HttpLog.save_in_db(
+            method: req.header.request_method,
+            url: req.header.request_uri,
+            request_body: req.body,
+            request_headers: req.headers,
+            response_code: res.status_code,
+            response_body: res.body,
+            response_headers: res.headers,
+            benchmark: bm,
+            encoding: res.headers['Content-Encoding'],
+            content_type: res.headers['Content-Type']
+        )
+        conn.push(res)
+      end
+
+      raise retryable_response unless retryable_response.nil?
+    end
+
+    class Session
+      alias orig_create_socket create_socket
+
+      # up to version 2.6, the method signature is `create_socket(site)`; after that,
+      # it's `create_socket(hort, port)`
+      if instance_method(:create_socket).arity == 1
+        def create_socket(site)
+          if HttpLog.url_approved?("#{site.host}:#{site.port}")
+            HttpLog.log_connection(site.host, site.port)
+          end
+          orig_create_socket(site)
+        end
+
+      else
+        def create_socket(host, port)
+          if HttpLog.url_approved?("#{host}:#{port}")
+            HttpLog.log_connection(host, port)
+          end
+          orig_create_socket(host, port)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/httplog/adapters/net_http.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require 'securerandom'
+module Net
+  class HTTP
+    alias orig_request request unless method_defined?(:orig_request)
+    alias orig_connect connect unless method_defined?(:orig_connect)
+
+    def request(req, body = nil, &block)
+      url = "http://#{@address}:#{@port}#{req.path}"
+
+      #req['al-source'] = req['X-Request-Id'] if req['X-Request-Id']
+      req['Al-Request-Client-Id'] = SecureRandom.uuid
+      req['al-source'] = Thread.current["al_request_id"] if Thread.current["al_request_id"]
+
+
+
+      timestamp = nil
+
+      bm = Benchmark.realtime do
+        timestamp= Time.now.to_i
+        @response = orig_request(req, body, &block)
+      end
+
+      c = InfluxDB::Rails.configuration
+      is_influxdb = (c.influxdb_hosts.include? @address ) && (@port == c.influxdb_port)
+
+
+      if !is_influxdb && (HttpLog.url_approved?(url) && started?)
+        HttpLog.save_in_db(
+            method: req.method,
+            url: url,
+            timestamp: timestamp,
+            request_body: req.body.nil? || req.body.empty? ? body : req.body,
+            request_headers: req.each_header.collect,
+            response_code: @response.code,
+            response_body: @response.body,
+            response_headers: @response.each_header.collect,
+            benchmark: bm,
+            encoding: @response['Content-Encoding'],
+            content_type: @response['Content-Type']
+        )
+      end
+
+      @response
+    end
+
+    def connect
+      HttpLog.log_connection(@address, @port) if !started? && HttpLog.url_approved?("#{@address}:#{@port}")
+
+      orig_connect
+    end
+  end
+end