supergood 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 665ca96dbcbfec2b928ff9dd1828ad464d63b23048346ee0324cbeb2b2f22977
-  data.tar.gz: e29262ab2a84f91991bb912223acf3d23e2e9332cbd0a33d6ec03db6b8388be0
+  metadata.gz: '04808e64355a5f8aba52cf3c3bcda9e16489ad70b4013a3d2eaa08bb673c8d76'
+  data.tar.gz: b9dbf12918f60e5760a3bc3fb27107025da236ef70e2fcdfa4ce610c40c830ee
 SHA512:
-  metadata.gz: a1b3f9b9f987bc19cf9e596126830576374cd75d3eb5179d1a9615f137191440bba6999a376a207847626ad2ee1041662fd2ca45be5c9d8ce88aff1c093cb28d
-  data.tar.gz: e96124b5501e72db95ac4e6c9e76c69896f6c8d0542b33c085d060d43e73d9da16f998fcd0a880dfc5d847f39b8d30c27b81963442965d26e3a86649a629063c
+  metadata.gz: 98a2fdd4c0fc38d74288abc6e8e9360995d8d1cd171142d15e12750b29c03310a2d6a7dc3bf4dbde0548db1fedd4e73b421ee2885068cffc3447c21d5aac037a
+  data.tar.gz: 2611eccbf1fd3f712b2cbbb67504151a581ea589947beb7f2d2cfb38388597940c3f1647f7040d948f1d9cb1010fef2d59c290a6348de1323f8527956e3bd0ee

data/lib/supergood/api.rb

@@ -1,19 +1,13 @@
 require 'faraday'
+require 'dotenv'
+
+Dotenv.load
 
 module Supergood
   class Api
-    DEFAULT_SUPERGOOD_BASE_URL = 'https://dashboard.supergood.ai'
-    DEFAULT_SUPERGOOD_CONFIG = {
-      flush_interval: 1,
-      event_sink_endpoint: DEFAULT_SUPERGOOD_BASE_URL + '/api/events',
-      error_sink_endpoint: DEFAULT_SUPERGOOD_BASE_URL + '/api/errors',
-      keys_to_hash: ['request.body', 'response.body'],
-      ignored_domains: []
-    }
-
     def initialize(header_options, base_url)
+      @base_url = base_url
       @header_options = header_options
-      @config_fetch_url = base_url + '/api/config'
     end
 
     def log
@@ -24,25 +18,46 @@ module Supergood
       @log = logger
     end
 
-    def set_event_sink_url(url)
-      @event_sink_url = url
+    def set_event_sink_endpoint(endpoint)
+      @event_sink_endpoint = endpoint
     end
 
-    def set_error_sink_url(url)
-      @error_sink_url = url
+    def set_error_sink_endpoint(endpoint)
+      @error_sink_endpoint = endpoint
     end
 
     def post_events(payload)
-      Faraday.post(@event_sink_url, payload, @header_options)
+      conn = Faraday.new(url: @base_url, headers: @header_options)
+      response = conn.post(@event_sink_endpoint, body = payload.to_json, headers = @header_options)
+      if response.status == 200
+        return JSON.parse(response.body, symbolize_names: true)
+      elsif response.status == 401
+        raise SupergoodException.new ERRORS[:UNAUTHORIZED]
+      elsif response.status != 200 && response.status != 201
+        raise SupergoodException.new ERRORS[:POSTING_EVENTS]
+      end
     end
 
     def post_errors(payload)
-      Faraday.post(@event_sink_url, payload, @header_options)
+      conn = Faraday.new(url: @base_url, headers: @header_options)
+      response = conn.post(@error_sink_endpoint, body = payload.to_json, headers = @header_options)
+      if response.status == 200
+        return JSON.parse(response.body, symbolize_names: true)
+      else
+        @log.warn(ERRORS[:POSTING_ERRORS])
+      end
     end
 
     def fetch_config
-      # Faraday.get(config_fetch_url, @header_options)
-      DEFAULT_SUPERGOOD_CONFIG
+      conn = Faraday.new(url: @base_url, headers: @header_options)
+      response = conn.get('/api/config')
+      if response.status == 200
+        return JSON.parse(response.body, symbolize_names: true)
+      elsif response.status == 401
+        raise SupergoodException.new ERRORS[:UNAUTHORIZED]
+      elsif response.status != 200 && response.status != 201
+        raise SupergoodException.new ERRORS[:FETCHING_CONFIG]
+      end
     end
   end
 end

data/lib/supergood/client.rb

@@ -1,10 +1,11 @@
-require 'webmock'
 require 'json'
-require 'net/http'
-require 'uri'
 require 'securerandom'
 require 'dotenv'
 require 'base64'
+require 'uri'
+
+require_relative 'vendors/http'
+require_relative 'vendors/net-http'
 
 Dotenv.load
 
@@ -14,34 +15,38 @@ module Supergood
 
   class << self
     def init(supergood_client_id=nil, supergood_client_secret=nil, base_url=nil)
-
       supergood_client_id = supergood_client_id || ENV['SUPERGOOD_CLIENT_ID']
       supergood_client_secret = supergood_client_secret || ENV['SUPERGOOD_CLIENT_SECRET']
-      base_url = base_url || ENV['SUPERGOOD_BASE_URL'] || DEFAULT_SUPERGOOD_BASE_URL
-      puts "Initializing Supergood with client_id: #{supergood_client_id}, client_secret: #{supergood_client_secret}, base_url: #{base_url}"
-      header_options = {
-        'headers' => {
-          'Content-Type' => 'application/json',
-          'Authorization' => 'Basic ' + Base64.encode64(supergood_client_id + ':' + supergood_client_secret)
-        }
-      }
 
-      @api = Supergood::Api.new(header_options, base_url)
-      @logger = Supergood::Logger.new(@api, header_options, base_url)
+      if !supergood_client_id
+        raise SupergoodException.new ERRORS[:NO_CLIENT_ID]
+      end
+
+      if !supergood_client_secret
+        raise SupergoodException.new ERRORS[:NO_CLIENT_SECRET]
+      end
 
-      config = api.fetch_config()
+      @base_url = base_url || ENV['SUPERGOOD_BASE_URL'] || DEFAULT_SUPERGOOD_BASE_URL
+      header_options = {
+        'Content-Type' => 'application/json',
+        'Authorization' => 'Basic ' + Base64.encode64(supergood_client_id + ':' + supergood_client_secret).gsub(/\n/, '')
+      }
 
-      @ignored_domains = config[:ignored_domains]
-      @keys_to_hash = config[:keys_to_hash]
+      @api = Supergood::Api.new(header_options, @base_url)
+      @config = @api.fetch_config
+      @ignored_domains = @config[:ignoredDomains]
+      @keys_to_hash = @config[:keysToHash]
+      @logger = Supergood::Logger.new(@api, @config, header_options)
 
-      api.set_error_sink_url(base_url + config[:error_sink_endpoint])
-      api.set_event_sink_url(base_url + config[:event_sink_endpoint])
-      api.set_logger(@logger)
+      @api.set_error_sink_endpoint(@config[:errorSinkEndpoint])
+      @api.set_event_sink_endpoint(@config[:eventSinkEndpoint])
+      @api.set_logger(@logger)
 
       @request_cache = {}
       @response_cache = {}
 
-      set_interval(config[:flush_interval]) { flush_cache }
+      @interval_thread = set_interval(@config[:flushInterval]) { flush_cache }
+      self
     end
 
     def log
@@ -67,12 +72,9 @@ module Supergood
       end
 
       begin
-        log.debug(data)
-        # api.post_events(data)
+        api.post_events(data)
       rescue => e
-        #TODO Add error posting to Supergood
-        puts "Error posting events: #{e}"
-        api.post_errors(e)
+        log.error(data, e, e.message)
       ensure
         @response_cache.clear
         @request_cache.clear if force
@@ -80,10 +82,16 @@ module Supergood
 
     end
 
+    def close(force = true)
+      log.debug('Cleaning up, flushing cache gracefully.')
+      @interval_thread.kill
+      flush_cache(force)
+    end
+
     def set_interval(delay)
       Thread.new do
         loop do
-          sleep delay
+          sleep delay / 1000.0
           yield # call passed block
         end
       end
@@ -97,109 +105,77 @@ module Supergood
       @instance ||= Supergood.new
     end
 
-    def intercept(http, request, request_body)
+    def intercept(request)
       request_id = SecureRandom.uuid
-      start_time = Time.now
-      response = yield
-    ensure
-      if log_event?(http, request)
-        time = ((Time.now - start_time) * 1000)
-        url_payload = parse_url(http, request)
-        @request_cache[request_id] = {
-          request: {
-            id: request_id,
-            method: request.method,
-            url: url_payload[:url],
-            protocol: url_payload[:protocol],
-            domain: url_payload[:domain],
-            path: url_payload[:path],
-            search: url_payload[:search],
-            body: hash_specified_keys(request.body),
-            header: hash_specified_keys(get_header(request)),
-          }
-        }
-        if defined?(response) && response
-          request_payload = @request_cache[request_id]
-          @response_cache[request_id] = {
-            request: request_payload,
-            response: {
-              status: response.code,
-              status_text: response.message,
-              header: hash_specified_keys(get_header(response)),
-              body: hash_specified_keys(response.body),
-            }
-          }
-          @request_cache.delete(request_id)
-        end
+      requested_at = Time.now
+      if !ignored?(request[:domain])
+        cache_request(request_id, requested_at, request)
       end
-    end
-
-    def log_event?(http, request)
-      !ignored?(http, request) && (http.started? || webmock?(http, request))
-    end
 
-    def ignored?(http, request)
-      url = request_url(http, request)
-      @ignored_domains.any? do |pattern|
-        url =~ pattern
+      response = yield
+      if !ignored?(request[:domain]) && defined?(response)
+        cache_response(request_id, requested_at, response)
       end
-    end
 
-    def webmock?(http, request)
-      return false unless defined?(::WebMock)
-      uri = request_uri_as_string(http, request)
-      method = request.method.downcase.to_sym
-      signature = WebMock::RequestSignature.new(method, uri)
-      ::WebMock.registered_request?(signature)
+      return response[:original_response]
     end
 
-    # TODO: Hash keys, move to Utils?
-    def hash_specified_keys(body_or_header)
-      body_or_header
-    end
-
-    def get_header(request_or_response)
-      header = {}
-      request_or_response.each_header do |k,v|
-        header[k] = v
+    def cache_request(request_id, requested_at, request)
+      begin
+        request_payload = {
+          id: request_id,
+          headers: request[:headers],
+          method: request[:method],
+          url: request[:url],
+          path: request[:path],
+          search: request[:search] || '',
+          body: Supergood::Utils.safe_parse_json(request[:body]),
+          requestedAt: requested_at
+        }
+        @request_cache[request_id] = {
+          request: request_payload
+        }
+      rescue => e
+        log.error({ request: request }, e, ERRORS[:CACHING_REQUEST])
       end
-      header
     end
 
-    def parse_url(http, request)
-      url = request_url(http, request)
-      uri = URI.parse(url)
-      {
-        url: url,
-        protocol: uri.scheme,
-        domain: uri.host,
-        path: uri.path,
-        search: uri.query,
-      }
-    end
-
-    def request_url(http, request)
-      URI::DEFAULT_PARSER.unescape("http#{"s" if http.use_ssl?}://#{http.address}:#{http.port}#{request.path}")
+    def cache_response(request_id, requested_at, response)
+      begin
+        responded_at = Time.now
+        duration = (responded_at - requested_at) * 1000
+        request_payload = @request_cache[request_id]
+        response_payload = {
+          headers: response[:headers],
+          status: response[:status],
+          statusText: response[:statusText],
+          body: Supergood::Utils.safe_parse_json(response[:body]),
+          respondedAt: responded_at,
+          duration: duration.round,
+        }
+        @response_cache[request_id] = Supergood::Utils.hash_values_from_keys(request_payload.merge({
+          response: response_payload
+        }), @keys_to_hash)
+        @request_cache.delete(request_id)
+      rescue => e
+        puts e
+        log.error(
+          { request: request_payload, response: response_payload },
+          e, ERRORS[:CACHING_RESPONSE]
+        )
+      end
     end
-  end
-end
-
 
-# Attach library to Net::HTTP and WebMock
-block = lambda do |a|
-  # raise instance_methods.inspect
-  alias request_without_net_http_logger request
-  def request(request, body = nil, &block)
-    Supergood.intercept(self, request, body) do
-      request_without_net_http_logger(request, body, &block)
+    def ignored?(domain)
+      base_domain = URI.parse(@base_url).hostname
+      if domain == base_domain
+        return true
+      else
+        @ignored_domains.any? do |ignored_domain|
+          pattern = URI.parse(ignored_domain).hostname
+          domain =~ pattern
+        end
+      end
     end
   end
 end
-
-if defined?(::WebMock)
-  klass = WebMock::HttpLibAdapters::NetHttpAdapter.instance_variable_get("@webMockNetHTTP")
-  # raise klass.instance_methods.inspect
-  klass.class_eval(&block)
-end
-
-Net::HTTP.class_eval(&block)

data/lib/supergood/constants.rb

@@ -0,0 +1,25 @@
+ERRORS = {
+  CACHING_RESPONSE: 'Error Caching Response',
+  CACHING_REQUEST: 'Error Caching Request',
+  DUMPING_DATA_TO_DISK: 'Error Dumping Data to Disk',
+  POSTING_EVENTS: 'Error Posting Events',
+  POSTING_ERRORS: 'Error Posting Errors',
+  FETCHING_CONFIG: 'Error Fetching Config',
+  WRITING_TO_DISK: 'Error writing to disk',
+  TEST_ERROR: 'Test Error for Testing Purposes',
+  UNAUTHORIZED: 'Unauthorized: Invalid Client ID or Secret. Exiting.',
+  NO_CLIENT_ID:
+    'No Client ID Provided, set SUPERGOOD_CLIENT_ID or pass it as an argument',
+  NO_CLIENT_SECRET:
+    'No Client Secret Provided, set SUPERGOOD_CLIENT_SECRET or pass it as an argument'
+};
+
+DEFAULT_SUPERGOOD_BYTE_LIMIT = 500000
+
+# GZIP_START_BYTES = b'\x1f\x8b'
+
+class SupergoodException < StandardError
+  def initialize(msg = message)
+    super(msg)
+  end
+end

data/lib/supergood/logger.rb

@@ -5,20 +5,27 @@ Dotenv.load
 
 module Supergood
   class Logger < Logger
-    def initialize(post_errors, config, header_options)
+    def initialize(api, config, header_options)
       super(STDOUT)
-      @post_errors = post_errors
+      @api = api
       @config = config
       @header_options = header_options
     end
 
-    def post_errors
-      @post_errors
-    end
-
-    def warn(payload, error, msg)
-      super
-      post_errors({ error: error, message: msg, payload: payload })
+    def error(data, error, msg)
+      super(error)
+      @api.post_errors(
+        {
+          error: error.backtrace.join('\n'),
+          message: msg,
+          payload: {
+            config: @config,
+            data: data,
+            packageName: 'supergood-rb',
+            packageVersion: Supergood::VERSION
+          }
+        }
+      )
     end
 
     def debug(payload)

data/lib/supergood/utils.rb

@@ -1,8 +1,72 @@
 require 'rudash'
+require 'digest'
 
 module Supergood
   module Utils
-    def hash_specified_keys
+    def self.hash_value(input)
+      hash = Digest::SHA1.new
+      if input == nil
+        return ''
+      elsif input.class == Array
+        return [Base64.strict_encode64(hash.update(input.to_json).to_s)]
+      elsif input.class == Hash
+        return {'hashed': Base64.strict_encode64(hash.update(input.to_json).to_s)}
+      elsif input.class == String
+        return Base64.strict_encode64(hash.update(input).to_s)
+      end
+    end
+
+    # Hash values from specified keys, or hash if the bodies exceed a byte limit
+    def self.hash_values_from_keys(obj, keys_to_hash, byte_limit=DEFAULT_SUPERGOOD_BYTE_LIMIT)
+      _obj = obj
+
+      if !keys_to_hash.include?('response.body')
+        payload = R_.get(_obj, 'response.body')
+        payload_size = payload.to_s.length()
+        if(payload_size >= byte_limit)
+          R_.set(_obj, 'response.body', Supergood::Utils.hash_value(payload))
+        end
+      end
+
+      if !keys_to_hash.include?('request.body')
+        payload = R_.get(_obj, 'request.body')
+        payload_size = payload.to_s.length()
+        if(payload_size >= byte_limit)
+          R_.set(_obj, 'request.body', Supergood::Utils.hash_value(payload))
+        end
+      end
+
+      keys_to_hash.each { |key|
+        value = R_.get(_obj, key)
+        if !!value
+          R_.set(_obj, key, Supergood::Utils.hash_value(value))
+        end
+      }
+
+      return _obj
+    end
+
+    def self.safe_parse_json(input)
+      if !input || input == ''
+        return ''
+      end
+
+      begin
+        return JSON.parse(input)
+      rescue => e
+        input
+      end
+    end
+    def self.get_header(request_or_response)
+      header = {}
+      request_or_response.each_header do |k,v|
+        header[k] = v
+      end
+      header
+    end
+
+    def self.request_url(http, request)
+      URI::DEFAULT_PARSER.unescape("http#{"s" if http.use_ssl?}://#{http.address}#{request.path}")
     end
   end
 end

data/lib/supergood/vendors/http.rb

@@ -0,0 +1,34 @@
+module Supergood
+  module Vendor
+    module HTTPrb
+      if defined?(::HTTP)
+        HTTP::Client.class_eval {
+          alias original_perform perform
+          def perform(original_request_payload, original_options)
+            request = {
+              headers: original_request_payload.headers.to_hash,
+              method: original_request_payload.verb.upcase.to_s,
+              body: Supergood::Utils.safe_parse_json(original_request_payload.body.source),
+              url: original_request_payload.uri.to_s,
+              path: original_request_payload.uri.path,
+              search: original_request_payload.uri.query,
+              domain: original_request_payload.uri.host
+            }
+            Supergood.intercept(request) do
+              original_response = original_perform(original_request_payload, original_options)
+              status, statusText = original_response.status.to_s.split(' ')
+              {
+                headers: original_response.headers.to_hash,
+                status: status,
+                statusText: statusText,
+                body: Supergood::Utils.safe_parse_json(original_response),
+                original_response: original_response
+              }
+            end
+          end
+        }
+      end
+    end
+  end
+end
+

data/lib/supergood/vendors/net-http.rb

@@ -0,0 +1,46 @@
+
+require 'net/http'
+require 'uri'
+
+module Supergood
+  module Vendor
+    module NetHTTP
+      block = lambda do |x|
+        alias original_request_method request
+        def request(original_request_payload, body = nil, &block)
+          http = self;
+          url = Supergood::Utils.request_url(http, original_request_payload)
+          uri = URI.parse(url)
+          request = {
+            headers: Supergood::Utils.get_header(original_request_payload),
+            method: original_request_payload.method,
+            body: original_request_payload.body,
+            url: url,
+            path: original_request_payload.path,
+            search: uri.query,
+            domain: uri.host,
+          }
+          Supergood.intercept(request) do
+            original_response = original_request_method(original_request_payload, body, &block)
+            {
+              headers: Supergood::Utils.get_header(original_response),
+              status: original_response.code,
+              statusText: original_response.message,
+              body: original_response.body,
+              original_response: original_response
+            }
+          end
+        end
+      end
+
+      if defined?(Net::HTTP)
+        Net::HTTP.class_eval(&block)
+      end
+
+      if defined?(::WebMock)
+        WebMock::HttpLibAdapters::NetHttpAdapter.instance_variable_get("@webMockNetHTTP").class_eval(&block)
+      end
+    end
+  end
+end
+

data/lib/supergood/version.rb

@@ -0,0 +1,3 @@
+module Supergood
+  VERSION = '0.0.2'.freeze
+end

data/lib/supergood.rb

@@ -3,4 +3,6 @@ module Supergood
   require_relative 'supergood/logger'
   require_relative 'supergood/client'
   require_relative 'supergood/utils'
+  require_relative 'supergood/constants'
+  require_relative 'supergood/version'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: supergood
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Alex Klarfeld
@@ -19,14 +19,18 @@ files:
 - lib/supergood.rb
 - lib/supergood/api.rb
 - lib/supergood/client.rb
+- lib/supergood/constants.rb
 - lib/supergood/logger.rb
 - lib/supergood/utils.rb
-- lib/version.rb
+- lib/supergood/vendors/http.rb
+- lib/supergood/vendors/net-http.rb
+- lib/supergood/version.rb
 homepage: https://supergood.ai
 licenses:
-- Business Source License 1.1
+- Nonstandard
 metadata:
   source_code_uri: https://github.com/supergoodsystems/supergood-rb
+  license: BUSL-1.1
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/version.rb

@@ -1,3 +0,0 @@
-module Supergood
-  VERSION = '0.0.1'.freeze
-end