liveqa 1.4.6

data/lib/liveqa/message.rb

@@ -0,0 +1,50 @@
+module LiveQA
+  ##
+  # == LiveQA \Message
+  #
+  # Return the base message for an event
+  class Message
+    class << self
+
+      def to_h
+        Util.deep_compact(
+          tracker_id: tracker_id,
+          message_id: SecureRandom.uuid,
+          timestamp: Time.now.utc.iso8601,
+          session_tracker_id: LiveQA::Store.get(:tracker_id),
+          library: library,
+          server: server,
+          request: LiveQA::Store.get(:request),
+          worker: LiveQA::Store.get(:worker),
+          stack: LiveQA::Store.get(:stack),
+          environement: LiveQA::Store.get(:environement)
+        )
+      end
+
+      private
+
+      def tracker_id
+        return LiveQA::Store.get(:tracker_id) if LiveQA::Store.exist?(:tracker_id)
+
+        LiveQA::Store.set(:tracker_id, SecureRandom.uuid)
+      end
+
+      def library
+        {
+          name: LiveQA::LIBRARY_NAME,
+          language: 'ruby',
+          version: LiveQA::VERSION
+        }
+      end
+
+      def server
+        {
+          host: Socket.gethostname,
+          pid: Process.pid,
+          software: LiveQA::Store.get(:server_software)
+        }
+      end
+
+    end
+  end
+end

data/lib/liveqa/plugins/rack/middleware.rb

@@ -0,0 +1,121 @@
+require 'uri'
+
+module LiveQA
+  module Plugins
+    module Rack
+      ##
+      # LiveQA \Plugins \Rack \Middleware
+      #
+      # Middleware for Rack
+      #
+      class Middleware
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          request = ::Rack::Request.new(env)
+
+          store_tracker(request)
+          store_request_data(request)
+          store_stack
+
+          LiveQA::Plugins::Rails::MiddlewareData.store_data(request) if defined?(::Rails)
+
+          status, headers, body = @app.call(env)
+
+          write_cookie_tracker_id!(headers)
+
+          [status, headers, body]
+        ensure
+          LiveQA::Store.clear!
+        end
+
+        private
+
+        def tracker_id_name
+          'liveqa_tracker_id'.freeze
+        end
+
+        def store_tracker(request)
+          LiveQA::Store.set(
+            :tracker_id,
+            request.cookies[tracker_id_name] || SecureRandom.uuid
+          )
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def store_request_data(request)
+          LiveQA::Store.set(
+            :request,
+            url: obfuscate_uri(request.url),
+            ssl: request.ssl?,
+            host: request.host,
+            port: request.port,
+            path: request.path,
+            referrer: obfuscate_uri(request.referrer),
+            method: request.request_method,
+            xhr: request.xhr?,
+            user_agent: request.user_agent,
+            ip: request.ip,
+            get_params: Util.deep_obfuscate_value(
+              request.GET,
+              LiveQA.configurations.obfuscated_fields
+            ),
+            post_params: Util.deep_obfuscate_value(
+              request.POST,
+              LiveQA.configurations.obfuscated_fields
+            )
+          )
+
+          LiveQA::Store.bulk_set(
+            server_software: request.env['SERVER_SOFTWARE']
+          )
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def store_stack
+          stack = LiveQA::Store.get(:stack) || []
+
+          LiveQA::Store.set(
+            :stack,
+            stack.push(
+              name: 'rack',
+              version: ::Rack.version
+            )
+          )
+        end
+
+        def write_cookie_tracker_id!(headers)
+          ::Rack::Utils.set_cookie_header!(
+            headers || {},
+            tracker_id_name,
+            value: LiveQA::Store.get(:tracker_id),
+            path: '/'
+          )
+        end
+
+        def obfuscate_uri(url)
+          uri = URI.parse(url)
+
+          params =
+            Util.deep_obfuscate_value(
+              ::Rack::Utils.parse_query(uri.query),
+              LiveQA.configurations.obfuscated_fields,
+              'HIDDEN'
+            )
+
+          return url if params.blank?
+
+          uri.merge(
+            "?#{::Rack::Utils.build_query(params)}"
+          ).to_s
+        rescue
+          ''
+        end
+
+      end
+    end
+  end
+end

data/lib/liveqa/plugins/rails/middleware_data.rb

@@ -0,0 +1,44 @@
+module LiveQA
+  module Plugins
+    module Rails
+      class MiddlewareData
+
+        class << self
+
+          def store_data(request)
+            LiveQA::Store.bulk_set(
+              environement: ::Rails.env
+            )
+            store_request_data(request)
+            store_framework
+          end
+
+          private
+
+          def store_request_data(request)
+            object = LiveQA::Store.get(:request) || {}
+
+            LiveQA::Store.set(
+              :request,
+              object.merge(id: request.env['action_dispatch.request_id'])
+            )
+          end
+
+          def store_framework
+            stack = LiveQA::Store.get(:stack) || []
+
+            LiveQA::Store.set(
+              :stack,
+              stack.push(
+                name: 'rails',
+                version: ::Rails.version
+              )
+            )
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/liveqa/plugins/rails/railtie.rb

@@ -0,0 +1,23 @@
+module LiveQA
+  module Plugins
+    module Rails
+      class Railtie < ::Rails::Railtie
+
+        initializer 'liveqa.middleware' do |app|
+          app.config.middleware.use(LiveQA::Plugins::Rack::Middleware)
+
+          if ActiveSupport.const_defined?(:Reloader) && ActiveSupport::Reloader.respond_to?(:to_complete)
+            ActiveSupport::Reloader.to_complete do
+              LiveQA::Store.clear!
+            end
+          elsif ActionDispatch.const_defined?(:Reloader) && ActionDispatch::Reloader.respond_to?(:to_cleanup)
+            ActionDispatch::Reloader.to_cleanup do
+              LiveQA::Store.clear!
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/liveqa/plugins/sidekiq/client_middleware.rb

@@ -0,0 +1,19 @@
+module LiveQA
+  module Plugins
+    module Sidekiq
+      ##
+      # LiveQA \Plugins \Sidekiq \Client \Middleware
+      #
+      # Client middleware for sidekiq
+      #
+      class ClientMiddleware
+
+        def call(_worker_class, job, _queue, _redis_pool)
+          job['liveqa_store'] = LiveQA::Store.store
+          yield
+        end
+
+      end
+    end
+  end
+end

data/lib/liveqa/plugins/sidekiq/load.rb

@@ -0,0 +1,14 @@
+require 'liveqa/plugins/sidekiq/client_middleware'
+require 'liveqa/plugins/sidekiq/server_middleware'
+
+Sidekiq.configure_client do |config|
+  config.client_middleware do |chain|
+    chain.add LiveQA::Plugins::Sidekiq::ClientMiddleware
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware do |chain|
+    chain.add LiveQA::Plugins::Sidekiq::ServerMiddleware
+  end
+end

data/lib/liveqa/plugins/sidekiq/server_middleware.rb

@@ -0,0 +1,47 @@
+module LiveQA
+  module Plugins
+    module Sidekiq
+      ##
+      # LiveQA \Plugins \Sidekiq \Server \Middleware
+      #
+      # Server middleware for sidekiq
+      #
+      class ServerMiddleware
+
+        def call(_worker, job, _queue)
+          LiveQA::Store.load_from_hash(job['liveqa_store'])
+          store_worker_data(job)
+          yield
+        ensure
+          LiveQA::Store.clear!
+        end
+
+        private
+
+        def store_worker_data(job)
+          LiveQA::Store.set(
+            :worker,
+            name: 'sidekiq',
+            version: ::Sidekiq::VERSION,
+            queue: job['queue'],
+            class: job['class'],
+            id: job['jid'],
+            created_at: convert_to_iso8601(job['created_at']),
+            process_at: convert_to_iso8601(job['enqueued_at']),
+            args: job['args'],
+            retried: job['retry_count'].is_a?(Integer),
+            retry_number: job['retry_count'],
+            failed_at: convert_to_iso8601(job['failed_at'])
+          )
+        end
+
+        def convert_to_iso8601(int_time)
+          Time.at(int_time).utc.iso8601
+        rescue
+          nil
+        end
+
+      end
+    end
+  end
+end

data/lib/liveqa/plugins.rb

@@ -0,0 +1,16 @@
+##
+# Rack & Rails
+#
+if defined?(Rack)
+  require 'liveqa/plugins/rack/middleware'
+
+  if defined?(Rails)
+    require 'liveqa/plugins/rails/railtie'
+    require 'liveqa/plugins/rails/middleware_data'
+  end
+end
+
+##
+# Sidekiq
+#
+require 'liveqa/plugins/sidekiq/load' if defined?(Sidekiq)

data/lib/liveqa/request.rb

@@ -0,0 +1,132 @@
+module LiveQA
+  ##
+  # == LiveQA \Request
+  #
+  # Build request
+  class Request
+    class << self
+
+      def execute(params = {})
+        klass = new(params)
+
+        if params[:method] == :post
+          klass.post
+        elsif params[:method] == :put
+          klass.put
+        elsif params[:method] == :delete
+          klass.delete
+        elsif params[:method] == :get
+          klass.get
+        else
+          raise LiveQA::UnknownRequestMethod, "#{params[:method]} haven't been implemented"
+        end
+      end
+
+      def post(params = {})
+        new(params).post
+      end
+
+      def put(params = {})
+        new(params).put
+      end
+
+      def get(params = {})
+        new(params).get
+      end
+
+      def delete(params = {})
+        new(params).delete
+      end
+    end
+
+    attr_reader :params, :http, :request
+
+    def initialize(params = {})
+      @params = params
+      @http   = Net::HTTP.new(uri.host, uri.port, uri_proxy.host, uri_proxy.port)
+
+      setup_ssl if params[:use_ssl]
+    end
+
+    def post
+      @request = Net::HTTP::Post.new(uri.path)
+
+      set_header
+      request.body = params[:payload]
+
+      handle_request
+    end
+
+    def put
+      @request = Net::HTTP::Put.new(uri.path)
+
+      request.body = params[:payload]
+
+      handle_request
+    end
+
+    def get
+      @request = Net::HTTP::Get.new(uri)
+
+      set_header
+
+      handle_request
+    end
+
+    def delete
+      @request = Net::HTTP::Delete.new(uri.path)
+
+      request.body = params[:payload]
+
+      handle_request
+    end
+
+    private
+
+    def handle_request
+      response = http.request(request)
+
+      case [response.code_type]
+      when [Net::HTTPOK], [Net::HTTPCreated], [Net::HTTPAccepted]
+        response
+      when [Net::HTTPUnauthorized]
+        raise RequestError.new(response, message: 'Unauthorized, please check your api key')
+      when [Net::HTTPNotFound]
+        raise RequestError.new(response, message: 'Requested Resource not found')
+      when [Net::HTTPRequestTimeOut]
+        raise RequestError.new(response, message: 'Server timeout, verify status of the server')
+      when [Net::HTTPInternalServerError]
+        raise RequestError.new(response, message: 'Server Error, please check with LiveQA')
+      else
+        raise RequestError, response
+      end
+    end
+
+    def set_header
+      params[:headers].each do |(type, value)|
+        formated_type = type.to_s.split(/_/).map(&:capitalize).join('-')
+        request[formated_type] = value
+      end
+    end
+
+    def setup_ssl
+      http.use_ssl     = true
+      http.ca_file     = params[:ca_file]
+      http.verify_mode = params[:verify_mode]
+    end
+
+    def uri
+      @uri ||= URI(params[:url])
+    end
+
+    def uri_proxy
+      @uri_proxy ||=
+        if params[:proxy]
+          URI(params[:proxy])
+        else
+          OpenStruct.new
+        end
+    end
+
+  end
+end

data/lib/liveqa/store.rb

@@ -0,0 +1,49 @@
+module LiveQA
+  ##
+  # == LiveQA \Store
+  #
+  # Store environement data
+  #
+  class Store
+    class << self
+
+      def store
+        Thread.current[:request_store] ||= {}
+      end
+
+      def clear!
+        Thread.current[:request_store] = {}
+      end
+
+      def load_from_hash(object = {})
+        clear!
+        bulk_set(Util.deep_symbolize_key(object)) if object.is_a?(Hash)
+      end
+
+      def get(key)
+        store[key]
+      end
+      alias [] get
+
+      def set(key, value)
+        store[key] = value
+      end
+      alias []= set
+
+      def bulk_set(attributes = {})
+        attributes.each do |(key, value)|
+          set(key, value)
+        end
+      end
+
+      def exist?(key)
+        store.key?(key)
+      end
+
+      def delete(key, &block)
+        store.delete(key, &block)
+      end
+
+    end
+  end
+end

data/lib/liveqa/util.rb

@@ -0,0 +1,148 @@
+module LiveQA
+  module Util
+    class << self
+
+      DATE_FORMAT = '%Y/%m/%d'.freeze
+      OBFUSCATED  = '[HIDDEN]'.freeze
+
+      ##
+      # Remove nil value from hash
+      #
+      # @return [Hash]
+      def compact(hash)
+        hash.reject { |_, value| value.nil? }
+      end
+
+      ##
+      # Remove nil value from hash recursively
+      #
+      # @return [Hash]
+      def deep_compact(object)
+        object.each_with_object({}) do |(key, value), result|
+          if value.is_a?(Hash)
+            value = deep_compact(value)
+            result[key] = value if !value.nil? && !value.empty?
+          else
+            result[key] = value unless value.nil?
+          end
+        end
+      end
+
+      ##
+      # Encodes a hash of parameters in a way that's suitable for use as query
+      # parameters in a URI or as form parameters in a request body. This mainly
+      # involves escaping special characters from parameter keys and values (e.g.
+      # `&`).
+      def encode_parameters(params = {})
+        params.map { |k, v| "#{url_encode(k)}=#{url_encode(v)}" }.join('&')
+      end
+
+      ##
+      # Encodes a string in a way that makes it suitable for use in a set of
+      # query parameters in a URI or in a set of form parameters in a request
+      # body.
+      def url_encode(key)
+        CGI.escape(key.to_s).gsub('%5B', '[').gsub('%5D', ']')
+      end
+
+      ##
+      # Convert string to underscore
+      #
+      # @param [String]
+      #
+      # @example
+      #   underscore('MyModel') => 'my_model'
+      def underscore(string)
+        string
+          .gsub(/::/, '/')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_')
+          .downcase
+      end
+
+      ##
+      # Deep convert hash to underscore case keys
+      #
+      # @param [Hash] hash to transform
+      #
+      # @return [Hash] transformed
+      def deep_underscore_key(hash_object)
+        deep_transform_keys_in_object(hash_object) do |key|
+          begin
+            underscore(key).to_sym
+          rescue
+            key
+          end
+        end
+      end
+
+      ##
+      # Deep convert hash to string keys
+      #
+      # @param [Hash] hash to transform
+      #
+      # @return [Hash] transformed
+      def deep_stringify_key(hash_object)
+        deep_transform_keys_in_object(hash_object) do |key|
+          begin
+            key.to_s
+          rescue
+            key
+          end
+        end
+      end
+
+      ##
+      # Deep convert hash to symbol keys
+      #
+      # @param [Hash] hash to transform
+      #
+      # @return [Hash] transformed
+      def deep_symbolize_key(hash_object)
+        deep_transform_keys_in_object(hash_object) do |key|
+          begin
+            key.to_sym
+          rescue
+            key
+          end
+        end
+      end
+
+      ##
+      # Deep remove key from hash
+      #
+      # @param [Hash] hash to obfuscate
+      #
+      # @return [Hash] hash obfuscated
+      def deep_obfuscate_value(object, fields, obfuscate_name = OBFUSCATED)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[key] = fields.include?(key.to_s) ? obfuscate_name : deep_obfuscate_value(value, fields)
+          end
+        when Array
+          object.map { |e| deep_obfuscate_value(e, fields) }
+        else
+          object
+        end
+      end
+
+      private
+
+      def deep_transform_keys_in_object(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[yield(key)] = deep_transform_keys_in_object(value, &block)
+          end
+        when Array
+          object.map { |e| deep_transform_keys_in_object(e, &block) }
+        else
+          object
+        end
+      end
+
+    end
+  end
+end

data/lib/liveqa/version.rb

@@ -0,0 +1,3 @@
+module LiveQA # :nodoc:
+  VERSION = '1.4.6'.freeze
+end