liveqa 1.4.6 → 1.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6664a0eec986c9adae1bacead1983dc3d739162
-  data.tar.gz: 7036cb5e2e9b76d770b9ac7a9a9a5902b09aa33c
+  metadata.gz: eedcd2fa28e813d0ebde999b52507b9dd8517668
+  data.tar.gz: a7739558d0b587260136c1d9a364dead5c283d43
 SHA512:
-  metadata.gz: b83f428273d7e13842210e74ae6676368f57da02a758ad6ef7d905bd391eb110556af77e3b9a59d36490702a5fd03f7f8212d477b1a63b5240223fe59bb5a140
-  data.tar.gz: 4b4424ca15f6043a65fcf1651eb66f9a06b409692a31ba14e284bcff9810635c42234b31eecd40074bf4ca0c8c6e5343a2884448ab2b9ba6122e0c043efac02c
+  metadata.gz: fd51dba298a81bc4f67a98db6ec8a2adc0cb418f9c474f787c39b6ffa9ed57393dff40c4d1e333f9afdebac25003872c9cbac51e34c53dddb754e18bde58eeb1
+  data.tar.gz: ecbb7fa596f45776d43abb4b7fc3c2e1f2d5b4e2853b6702da72a045c22d963a32a964e108c7075fe228dbbd09715130b4eb4147c4820fc640d1ac86d1ad78bf

data/.rubocop.yml

@@ -10,6 +10,8 @@ Metrics/MethodLength:
   Max: 20
 Metrics/CyclomaticComplexity:
   Max: 7
+Metrics/ModuleLength:
+  Enabled: false
 
 Layout/EmptyLinesAroundClassBody:
   Enabled: false

data/.travis.yml

@@ -5,6 +5,7 @@ rvm:
   - 2.2
   - 2.3
   - 2.4
+  - 2.5
 script:
   - bundle exec rspec spec
   - bundle exec rubocop .

data/README.md

@@ -20,19 +20,106 @@ gem 'liveqa'
 
 ```ruby
 LiveQA.configure do |config|
-  config.api_key = 'your-api-key'
+  ## 
+  # Account token can be found inside your environment settings
+  config.account_token = 'acc_xx'
+
+  ##
+  # The name of your space
+  config.space_name = 'LiveQA'
+
+  ##
+  # The name of your environement
+  config.environment_name = 'production'
+  
+  ## 
+  # If you use a proxy.
+  # default: nil
+  # config.proxy_url = ENV['HTTP_PROXY']
+
+  ## 
+  # If enabled is set to false nothing is send to the server
+  # default: true
+  # config.enabled = true
+
+  ## 
+  # Extra attributes to be obfuscated
+  # default: []
+  # config.obfuscated_fields = ['credit_card_number']
+
+  ## 
+  # Use an async handler to send data to the liveqa to
+  # avoid slowing down your application
+  # available option: :sidekiq
+  # default: nil
+  # config.async_handler = :sidekiq
+
+  ##
+  # Options to be passed to the async handler
+  # default: {}
+  # config.async_options = { queue: 'liveqa' }
+
+  ##
+  # Metadata is passed with every request to the server
+  # default: nil
+  # config.metadata = {
+  #.  customer: -> { current_customer.id},
+  #.  version: 42
+  # }
+  #
 end
 ```
 
 ## Usage
 
+### Track
+
+Track an event
+
+Attributes:
+
+* `String` event name
+* `Hash` event attributes
+
+```ruby
+LiveQA.track('my event',
+  user_id: 42,
+  properties: {
+      order_id: 84 
+  }
+);
+```
+
+### Identify
+
+Identify a user
+
+Attributes:
+
+* `String` user id from your database
+* `Hash` user attributes
+
+```ruby
+LiveQA.identify(42,
+  properties: {
+    name: 'John Doe' 
+  }
+);
+```
+
+### Watch
+
+Create a watcher
+
+Attributes:
+
+* `String|Integer` template flow name or id
+* `Hash` watcher attributes
+
 ```ruby
-LiveQA.track('my event', { 
-    user_id: 42,
-    properties: {
-        order_id: 84 
-    }
-});
+LiveQA.watch('My Flow',
+  expected_times: 42
+);
 ```
 
 ## Issues

data/lib/liveqa/api_operation/delete.rb

@@ -0,0 +1,38 @@
+module LiveQA
+  class APIOperation
+    ##
+    # == Delete a resource for the API
+    #
+    module Delete
+      module ClassMethods
+        ##
+        # Delete an API Resource
+        #
+        # @param [String] id for the request
+        # @param [Hash] Additional options for the request
+        #
+        # @return [LiveQA::Object] response from the API
+        def delete(id, options = {})
+          response = request(:delete, "#{resource_path}/#{id}", options)
+          initialize_from(response)
+        end
+      end
+
+      ##
+      # Delete an API Resources
+      #
+      # @param [Hash] Additional options for the request
+      #
+      # @return [LiveQA::Object] response from the API
+      def destroy(options = {})
+        response = request(:delete, "#{resource_path}/#{id}", {}, options)
+        update_from(response)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/liveqa/api_resource.rb

@@ -71,12 +71,11 @@ module LiveQA
           payload: payload.to_json,
           proxy:   configurations.proxy_url,
           use_ssl: configurations.http_secure
-        ).merge(headers).merge(options)
+        ).merge(headers(options)).merge(options)
 
-        Request.execute(request_options)
+        Request.execute(request_options).body
       rescue LiveQA::RequestError => error
         return error.http_body if error.http_status == 422
-        raise
       end
 
       private
@@ -104,12 +103,14 @@ module LiveQA
         }
       end
 
-      def headers
+      def headers(options)
         {
           headers: {
-            accept:       'application/json',
+            accept: 'application/json',
             content_type: 'application/json',
-            x_request_key: configurations.api_key
+            x_account_token: options.delete(:account_token) || configurations.account_token,
+            x_space_name: options.delete(:space_name) || configurations.space_name,
+            x_environment_name: options.delete(:environment_name) || configurations.environment_name
           }
         }
       end

data/lib/liveqa/async_handlers/base.rb

@@ -7,9 +7,7 @@ module LiveQA
       end
 
       def execute(args)
-        klass_name, method, payload, request_options = args
-
-        Object.const_get(klass_name).send(method.to_sym, payload, request_options)
+        Object.const_get(args[0]).send(args[1].to_sym, *args[2..-1])
       end
 
     end

data/lib/liveqa/config.rb

@@ -27,8 +27,16 @@ module LiveQA
     ].freeze
 
     ##
-    # @return [String] API key
-    attr_accessor :api_key
+    # @return [String] API account token
+    attr_accessor :account_token
+
+    ##
+    # @return [String] API space name
+    attr_accessor :space_name
+
+    ##
+    # @return [String] API environment name
+    attr_accessor :environment_name
 
     ##
     # @return [String] API host
@@ -62,20 +70,36 @@ module LiveQA
     # @return [Hash] options for asynchronous handler
     attr_accessor :async_options
 
+    ##
+    # @return [Hash] custom object properties
+    attr_accessor :custom_object_properties
+
+    ##
+    # @return [Hash] metadata to be attach to the payload
+    attr_accessor :metadata
+
     ##
     # @param [Hash{Symbol=>Object}]
     # Initialize and validate the configuration
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def initialize(options = {})
-      self.api_key           = options[:api_key]
-      self.api_host          = options[:api_host] || 'api.liveqa.io'
-      self.api_version       = options[:api_version] || 'v1'
-      self.proxy_url         = options[:proxy_url]
-      self.http_secure       = options[:http_secure] || true
-      self.enabled           = options[:enabled] || true
+      self.account_token = options[:account_token]
+      self.space_name = options[:space_name]
+      self.environment_name = options[:environment_name]
+      self.api_host = options[:api_host] || 'api.liveqa.io'
+      self.api_version = options[:api_version] || 'v1'
+      self.proxy_url = options[:proxy_url]
+      self.http_secure = options[:http_secure] || true
+      self.enabled = options[:enabled] || true
       self.obfuscated_fields = options[:obfuscated_fields] || []
-      self.async_handler     = options[:async_handler]
-      self.async_options     = options[:async_options] || {}
+      self.async_handler = options[:async_handler]
+      self.async_options = options[:async_options] || {}
+      self.custom_object_properties = options[:custom_object_properties] || {}
+      self.metadata = options[:metadata]
     end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/PerceivedComplexity
 
     ##
     # validate the configuration
@@ -84,7 +108,7 @@ module LiveQA
     def valid!
       format!
 
-      %i[api_key api_host api_version].each do |field|
+      %i[account_token space_name environment_name api_host api_version].each do |field|
         validate_presence(field)
       end
 

data/lib/liveqa/event.rb

@@ -2,21 +2,15 @@ module LiveQA
   ##
   # == LiveQA \Event
   #
+  # Accepted Methods:
+  #
+  # * update
+  #
   # @example: Usage
   #
   #   request = LiveQA::Event.create('Event Name') #=> #<LiveQA::Response...>
   #
   class Event < APIResource
     include LiveQA::APIOperation::Save
-
-    class << self
-
-      def build_payload(payload)
-        Message
-          .to_h
-          .merge(payload)
-      end
-
-    end
   end
 end

data/lib/liveqa/group.rb

@@ -0,0 +1,14 @@
+module LiveQA
+  ##
+  # == LiveQA \Group
+  #
+  # Create and update groups
+  #
+  # @example: Usage
+  #
+  #   request = LiveQA::Group.update('dc0b28d8a220', properties: { name: 'My Group' }) #=> #<LiveQA::Response...>
+  #
+  class Group < APIResource
+    include LiveQA::APIOperation::Save
+  end
+end

data/lib/liveqa/identity.rb

@@ -0,0 +1,16 @@
+module LiveQA
+  ##
+  # == LiveQA \Identity
+  #
+  # Create and update groups
+  #
+  # @example: Usage
+  #
+  #   request = LiveQA::Identity.update('dc0b28d8a220', properties: { name: 'My Identity' }) #=> #<LiveQA::Response...>
+  #
+  class Identity < APIResource
+    @resource_name = 'identities'
+
+    include LiveQA::APIOperation::Save
+  end
+end

data/lib/liveqa/liveqa_object.rb

@@ -12,27 +12,48 @@ module LiveQA
     # @return [Hash] JSON parsed response
     attr_reader :data
 
-    attr_reader :accepted
-    alias accepted? accepted
-
     attr_reader :errors
 
+    attr_reader :successful
+    alias successful? successful
+
     class << self
 
       ##
       # Initialize from the API response
       #
       # @return [LiveQA::LiveQAObject]
-      def initialize_from(_response = '')
-        object = new
+      def initialize_from(response, object = new)
+        object.load_response_api(response.is_a?(Hash) ? response : Util.safe_json_parse(response))
+        object.update_attributes(LiveQA::Util.except_keys(object.raw, :data))
+        if object.raw[:object] == 'list'
+          object.raw[:data].each do |response_object|
+            data = object.type_from_string_object(response_object[:object]).initialize_from(response_object)
 
-        object.successful = true
+            object.add_data(data)
+          end
+        end
 
         object
       end
 
     end
 
+    ##
+    # Update the object based on the response from the API
+    # Remove and new accessor
+    #
+    # @param [Hash] response
+    #
+    # @return [LiveQA::LiveQAObject]
+    def update_from(response)
+      self.class.initialize_from(response, self)
+
+      (@values.keys - raw.keys).each { |key| remove_accessor(key) }
+
+      self
+    end
+
     ##
     # Initialize and create accessor for values
     #
@@ -70,7 +91,7 @@ module LiveQA
 
     ##
     # @return [JSON] values to JSON
-    def to_json
+    def to_json(_object = nil)
       JSON.generate(@values)
     end
 
@@ -84,6 +105,15 @@ module LiveQA
       end
     end
 
+    ##
+    # Load the root components for the API response
+    #
+    # @param [Hash] values
+    def load_response_api(response)
+      @raw        = LiveQA::Util.deep_underscore_key(response)
+      @successful = true
+    end
+
     ##
     # Add data for sub-object
     #
@@ -92,7 +122,17 @@ module LiveQA
       @data << data
     end
 
-    protected
+    ##
+    # Create an object from a string
+    #
+    # @param [String] object to be build
+    #
+    # @return [Object]
+    def type_from_string_object(string_object)
+      klass_name = LiveQA::Util.camelize(string_object.to_s)
+
+      Object.const_get("LiveQA::#{klass_name}")
+    end
 
     def inspect
       id_string = respond_to?(:id) && !id.nil? ? " id=#{id}" : ''

data/lib/liveqa/message.rb

@@ -6,27 +6,31 @@ module LiveQA
   class Message
     class << self
 
-      def to_h
+      def base
         Util.deep_compact(
-          tracker_id: tracker_id,
           message_id: SecureRandom.uuid,
-          timestamp: Time.now.utc.iso8601,
-          session_tracker_id: LiveQA::Store.get(:tracker_id),
+          timestamp: Time.now.utc.iso8601(3),
+          session_tracker_id: session_tracker_id,
+          metadata: metadata
+        )
+      end
+
+      def extended
+        Util.deep_compact(
           library: library,
           server: server,
           request: LiveQA::Store.get(:request),
           worker: LiveQA::Store.get(:worker),
-          stack: LiveQA::Store.get(:stack),
-          environement: LiveQA::Store.get(:environement)
-        )
+          environment: LiveQA::Store.get(:environment)
+        ).merge(base)
       end
 
       private
 
-      def tracker_id
-        return LiveQA::Store.get(:tracker_id) if LiveQA::Store.exist?(:tracker_id)
+      def session_tracker_id
+        return LiveQA::Store.get(:session_tracker_id) if LiveQA::Store.exist?(:session_tracker_id)
 
-        LiveQA::Store.set(:tracker_id, SecureRandom.uuid)
+        LiveQA::Store.set(:session_tracker_id, SecureRandom.uuid)
       end
 
       def library
@@ -45,6 +49,23 @@ module LiveQA
         }
       end
 
+      def metadata
+        return nil if LiveQA.configurations.metadata.nil?
+
+        LiveQA.configurations.metadata.each_with_object({}) do |(key, value), hash|
+          if value.is_a?(Proc)
+            begin
+              hash[key] = value.call
+            rescue
+              nil
+            end
+            next
+          end
+
+          hash[key] = value
+        end
+      end
+
     end
   end
 end

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

@@ -18,15 +18,12 @@ module LiveQA
           request = ::Rack::Request.new(env)
 
           store_tracker(request)
-          store_request_data(request)
-          store_stack
+          store_request_data(request, env)
 
           LiveQA::Plugins::Rails::MiddlewareData.store_data(request) if defined?(::Rails)
-
           status, headers, body = @app.call(env)
 
-          write_cookie_tracker_id!(headers)
-
+          write_cookie_session_tracker_id!(headers, env)
           [status, headers, body]
         ensure
           LiveQA::Store.clear!
@@ -34,19 +31,18 @@ module LiveQA
 
         private
 
-        def tracker_id_name
+        def session_tracker_id_name
           'liveqa_tracker_id'.freeze
         end
 
         def store_tracker(request)
           LiveQA::Store.set(
-            :tracker_id,
-            request.cookies[tracker_id_name] || SecureRandom.uuid
+            :session_tracker_id,
+            request.cookies[session_tracker_id_name] || SecureRandom.uuid
           )
         end
 
-        # rubocop:disable Metrics/MethodLength
-        def store_request_data(request)
+        def store_request_data(request, env)
           LiveQA::Store.set(
             :request,
             url: obfuscate_uri(request.url),
@@ -59,40 +55,23 @@ module LiveQA
             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
-            )
+            get_params: obfuscation_get_params(request, 'GET'),
+            post_params: obfuscation_get_params(request, 'POST'),
+            headers: obfuscate_headers(env)
           )
 
           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)
+        def write_cookie_session_tracker_id!(headers, env)
           ::Rack::Utils.set_cookie_header!(
             headers || {},
-            tracker_id_name,
-            value: LiveQA::Store.get(:tracker_id),
-            path: '/'
+            session_tracker_id_name,
+            value: LiveQA::Store.get(:session_tracker_id),
+            path: '/',
+            secure: https_request?(env)
           )
         end
 
@@ -106,7 +85,7 @@ module LiveQA
               'HIDDEN'
             )
 
-          return url if params.blank?
+          return url if params.empty?
 
           uri.merge(
             "?#{::Rack::Utils.build_query(params)}"
@@ -115,6 +94,41 @@ module LiveQA
           ''
         end
 
+        def obfuscation_get_params(request, type)
+          Util.deep_obfuscate_value(
+            request.send(type),
+            LiveQA.configurations.obfuscated_fields
+          )
+        rescue
+          {}
+        end
+
+        # determines if a request is HTTPS based on headers and env variabled
+        def https_request?(env)
+          env['HTTPS'] == 'on' ||
+            env['HTTP_X_FORWARDED_SSL'] == 'on' ||
+            env['HTTP_X_FORWARDED_PROTO'].to_s.split(',').first == 'https' ||
+            env['rack.url_scheme'] == 'https'
+        end
+
+        def obfuscate_headers(env)
+          skip_headers = %w[HTTP_USER_AGENT HTTP_COOKIE HTTP_REFERER HTTP_HOST]
+
+          headers = env.keys.grep(/^HTTP_|^CONTENT_TYPE$|^CONTENT_LENGTH$/).each_with_object({}) do |key, hash|
+            next if skip_headers.include?(key)
+            name = key.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+
+            hash[name] = env[key]
+          end
+
+          Util.deep_obfuscate_value(
+            headers,
+            LiveQA.configurations.obfuscated_fields
+          )
+        rescue
+          {}
+        end
+
       end
     end
   end

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

@@ -0,0 +1,19 @@
+module LiveQA
+  module Plugins
+    module Rails
+      class Data
+
+        class << self
+
+          def store_data
+            LiveQA::Store.bulk_set(
+              environment: ::Rails.env
+            )
+          end
+
+        end
+
+      end
+    end
+  end
+end