supergood 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 665ca96dbcbfec2b928ff9dd1828ad464d63b23048346ee0324cbeb2b2f22977
+  data.tar.gz: e29262ab2a84f91991bb912223acf3d23e2e9332cbd0a33d6ec03db6b8388be0
+SHA512:
+  metadata.gz: a1b3f9b9f987bc19cf9e596126830576374cd75d3eb5179d1a9615f137191440bba6999a376a207847626ad2ee1041662fd2ca45be5c9d8ce88aff1c093cb28d
+  data.tar.gz: e96124b5501e72db95ac4e6c9e76c69896f6c8d0542b33c085d060d43e73d9da16f998fcd0a880dfc5d847f39b8d30c27b81963442965d26e3a86649a629063c

data/lib/supergood/api.rb

@@ -0,0 +1,48 @@
+require 'faraday'
+
+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)
+      @header_options = header_options
+      @config_fetch_url = base_url + '/api/config'
+    end
+
+    def log
+      @log
+    end
+
+    def set_logger(logger)
+      @log = logger
+    end
+
+    def set_event_sink_url(url)
+      @event_sink_url = url
+    end
+
+    def set_error_sink_url(url)
+      @error_sink_url = url
+    end
+
+    def post_events(payload)
+      Faraday.post(@event_sink_url, payload, @header_options)
+    end
+
+    def post_errors(payload)
+      Faraday.post(@event_sink_url, payload, @header_options)
+    end
+
+    def fetch_config
+      # Faraday.get(config_fetch_url, @header_options)
+      DEFAULT_SUPERGOOD_CONFIG
+    end
+  end
+end

data/lib/supergood/client.rb

@@ -0,0 +1,205 @@
+require 'webmock'
+require 'json'
+require 'net/http'
+require 'uri'
+require 'securerandom'
+require 'dotenv'
+require 'base64'
+
+Dotenv.load
+
+module Supergood
+
+  DEFAULT_SUPERGOOD_BASE_URL = 'https://dashboard.supergood.ai'
+
+  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)
+
+      config = api.fetch_config()
+
+      @ignored_domains = config[:ignored_domains]
+      @keys_to_hash = config[:keys_to_hash]
+
+      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)
+
+      @request_cache = {}
+      @response_cache = {}
+
+      set_interval(config[:flush_interval]) { flush_cache }
+    end
+
+    def log
+      @logger
+    end
+
+    def api
+      @api
+    end
+
+    def flush_cache(force = false)
+      # If there's notthing in the response cache, and we're not forcing a flush, then return
+      if @response_cache.empty? && !force
+        return
+      elsif force && @response_cache.empty? && @request_cache.empty?
+        return
+      end
+
+      data = @response_cache.values
+
+      if force
+        data += @request_cache.values
+      end
+
+      begin
+        log.debug(data)
+        # api.post_events(data)
+      rescue => e
+        #TODO Add error posting to Supergood
+        puts "Error posting events: #{e}"
+        api.post_errors(e)
+      ensure
+        @response_cache.clear
+        @request_cache.clear if force
+      end
+
+    end
+
+    def set_interval(delay)
+      Thread.new do
+        loop do
+          sleep delay
+          yield # call passed block
+        end
+      end
+    end
+
+    def self.intercept(*args, &block)
+      instance.intercept(*args, &block)
+    end
+
+    def self.instance
+      @instance ||= Supergood.new
+    end
+
+    def intercept(http, request, request_body)
+      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
+      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
+      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)
+    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
+      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}")
+    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)
+    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/logger.rb

@@ -0,0 +1,31 @@
+require 'logger'
+require 'dotenv'
+
+Dotenv.load
+
+module Supergood
+  class Logger < Logger
+    def initialize(post_errors, config, header_options)
+      super(STDOUT)
+      @post_errors = post_errors
+      @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 })
+    end
+
+    def debug(payload)
+      if(ENV['SUPERGOOD_LOG_LEVEL'] == 'debug')
+        super
+      end
+    end
+
+  end
+end

data/lib/supergood/utils.rb

@@ -0,0 +1,8 @@
+require 'rudash'
+
+module Supergood
+  module Utils
+    def hash_specified_keys
+    end
+  end
+end

data/lib/supergood.rb

@@ -0,0 +1,6 @@
+module Supergood
+  require_relative 'supergood/api'
+  require_relative 'supergood/logger'
+  require_relative 'supergood/client'
+  require_relative 'supergood/utils'
+end

data/lib/version.rb

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

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: supergood
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Klarfeld
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-03-13 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: alex@supergood.ai
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/supergood.rb
+- lib/supergood/api.rb
+- lib/supergood/client.rb
+- lib/supergood/logger.rb
+- lib/supergood/utils.rb
+- lib/version.rb
+homepage: https://supergood.ai
+licenses:
+- Business Source License 1.1
+metadata:
+  source_code_uri: https://github.com/supergoodsystems/supergood-rb
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Supergood - API monitoring
+test_files: []