datumfactory 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f894820936bc03f06a3b84379fe706d88c72dae1f32be39a752f96bd277181aa
-  data.tar.gz: 9db8449f2d72faecb1fc8190bcadd4dcd84125bc1cbe08bda89ca159b74d5162
+  metadata.gz: 1011bfbea1d54f85f28c0e299d808028e55aafd45364fb594f3af22e2f8f90af
+  data.tar.gz: 5cdfe12953c2cdd16884b02775aa5e630412fbb491390c54152e16720bb8729d
 SHA512:
-  metadata.gz: c4dc2807dd987364f0ed8f551302c1b1a930083a012f424323699d8586c1bc576c1f00b60183c73e0022cc2eaf2ba6edc5fb60cb911d481bf89c65f6191fe6a0
-  data.tar.gz: 87357100422226444c621efbadd5dd1dd28b7de744f8d116a21ca9f70dc87e0e2026cd843b11d59bcd4eba6a956a4c3acfd18aaa836a0f270804d435c622339a
+  metadata.gz: 5faa07f7b5174d0898d461eec68be975083429ab62922d7cae65382103f91214da14b18e0a5338c6e2e4e36d8cdd30b4a33a907116cd7de73289a5ac12ef2621
+  data.tar.gz: ee23e33eae5bf4e54cb3244edeec4604b200480155334967ed96185e169528098bcf5f03cd5b6a6d1c270b0e65e3a35a4daaba465a70f19423daf7bf6eec1c76

data/.rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  TargetRubyVersion: 2.6.5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    datumfactory (0.1.0)
+    datumfactory (0.2.0)
       httparty (~> 0.18.1)
 
 GEM

data/datumfactory.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 

data/lib/datumfactory.rb

@@ -13,7 +13,32 @@ module Datumfactory
     attr_reader :auth_token
 
     format :json
-    base_uri "datumfactory.com"
+    base_uri 'datumfactory.com'
+
+    def self.capture_event(container, auth_token, data, title, slug, description = nil)
+      body = {
+        query: {
+          event: {
+            data: data,
+            title: title,
+            description: description,
+            slug: slug
+          }
+        }
+      }
+
+      options = {
+        headers: {
+          'Content-Type' => 'application/json',
+          'X-API-Key' => auth_token.to_s
+        }
+      }
+
+      #options.merge!({ headers: { 'X-API-Key' => auth_token.to_s } })
+      options.merge!(body)
+      base_uri "https://#{container}.datumfactory.com"
+      post('/api/v1/events', options).parsed_response
+    end
 
     def initialize(site, email, password)
       self.class.base_uri "#{site}.datumfactory.com"

data/lib/datumfactory/config/defaults.rb

@@ -0,0 +1,21 @@
+require 'socket'
+
+module Datumfactory
+  class Config
+    class Boolean; end
+
+    DEVELOPMENT_ENVIRONMENTS = %w[development test].map(&:freeze).freeze
+
+    DEFAULT_PATHS = ['config/datumfactory.yml'].map(&:freeze).freeze
+
+    OPTIONS = {
+      api_key: {
+        description: 'The API key for your Datumfactory container.',
+        default: nil,
+        type: String
+      }
+    }.freeze
+
+    DEFAULTS = Hash[OPTIONS.map{|k,v| [k, v[:default]] }].freeze
+  end
+end

data/lib/datumfactory/config/yaml.rb

@@ -0,0 +1,73 @@
+require 'pathname'
+require 'yaml'
+require 'erb'
+
+module Datumfactory
+  class Config
+    module Yaml
+      DISALLOWED_KEYS = [:'config.path'].freeze
+
+      def self.new(path, env = 'production')
+        path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+
+        if !path.exist?
+          raise ConfigError, "The configuration file #{path} was not found."
+        elsif !path.file?
+          raise ConfigError, "The configuration file #{path} is not a file."
+        elsif !path.readable?
+          raise ConfigError, "The configuration file #{path} is not readable."
+        end
+
+        yaml = load_yaml(path)
+        yaml.merge!(yaml[env]) if yaml[env].kind_of?(Hash)
+
+        dotify_keys(yaml)
+      end
+
+      def self.load_yaml(path)
+        begin
+          yaml = YAML.load(ERB.new(path.read).result)
+        rescue => e
+          config_error = ConfigError.new(e.to_s)
+
+          if e.backtrace
+            backtrace = e.backtrace.map do |line|
+              if line.start_with?('(erb)'.freeze)
+                line.gsub('(erb)'.freeze, path.to_s)
+              else
+                line
+              end
+            end
+            config_error.set_backtrace(backtrace)
+          end
+
+          raise config_error
+        end
+
+        case yaml
+        when Hash
+          yaml
+        when NilClass, FalseClass
+          {}
+        else
+          raise ConfigError, "The configuration file #{path} is invalid."
+        end
+      end
+
+      def self.dotify_keys(hash, key_prefix = nil)
+        {}.tap do |new_hash|
+          hash.each_pair do |k,v|
+            k = [key_prefix, k].compact.join('.')
+            if v.kind_of?(Hash)
+              new_hash.update(dotify_keys(v, k))
+            else
+              next if DISALLOWED_KEYS.include?(k.to_sym)
+
+              new_hash[k.to_sym] = v
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datumfactory/util/config.rb

@@ -0,0 +1,390 @@
+require 'pathname'
+require 'delegate'
+require 'logger'
+require 'fileutils'
+require 'openssl'
+
+require 'datumfactory/version'
+require 'datumfactory/backend'
+require 'datumfactory/config/defaults'
+require 'datumfactory/util/http'
+
+module Datumfactory
+  class Config
+    extend Forwardable
+
+    class ConfigError < StandardError; end
+
+    KEY_REPLACEMENT = Regexp.new('[^a-z\d_]', Regexp::IGNORECASE).freeze
+
+    DOTTED_KEY = Regexp.new('\A([^\.]+)\.(.+)\z').freeze
+
+    NOT_BLANK = Regexp.new('\S').freeze
+
+    def initialize(opts = {})
+      @ruby = opts.freeze
+      @env = {}.freeze
+      @yaml = {}.freeze
+      @framework = {}.freeze
+    end
+
+    attr_accessor :ruby, :env, :yaml, :framework
+
+    def load!(framework: {}, env: ENV)
+      return self if @load
+
+      self.framework = framework.freeze
+      self.env = Env.new(env).freeze
+      load_config_from_disk {|yaml| self.yaml = yaml.freeze }
+      detect_revision!
+      @loaded = true
+      self
+    end
+
+    def configure
+      new_ruby = Ruby.new(self)
+      yield(new_ruby)
+      self.ruby = ruby.merge(new_ruby).freeze
+      @logger = @backend = nil
+      self
+    end
+
+    def backtrace_filter(&block)
+      if block_given?
+        warn('DEPRECATED: backtrace_filter is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#backtrace_filter')
+        self[:backtrace_filter] = block
+      end
+
+      self[:backtrace_filter]
+    end
+
+    def before_notify_hooks
+      (ruby[:before_notify] || []).clone
+    end
+
+    def exception_filter(&block)
+      if block_given?
+        warn('DEPRECATED: exception_filter is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#exception_filter')
+        self[:exception_filter] = block
+      end
+
+      self[:exception_filter]
+    end
+
+    def exception_fingerprint(&block)
+      if block_given?
+        warn('DEPRECATED: exception_fingerprint is deprecated. Please use before_notify instead. See https://docs.honeybadger.io/ruby/support/v4-upgrade#exception_fingerprint')
+        self[:exception_fingerprint] = block
+      end
+
+      self[:exception_fingerprint]
+    end
+
+    def get(key)
+      IVARS.each do |var|
+        source = instance_variable_get(var)
+        if source.has_key?(key)
+          return source[key]
+        end
+      end
+
+      DEFAULTS[key]
+    end
+    alias [] :get
+
+    def set(key, value)
+      self.ruby = ruby.merge(key => value).freeze
+      @logger = @backend = nil
+    end
+    alias []= :set
+
+    def to_hash(defaults = false)
+      hash = [:@ruby, :@env, :@yaml, :@framework].reverse.reduce({}) do |a,e|
+        a.merge!(instance_variable_get(e))
+      end
+
+      hash = DEFAULTS.merge(hash) if defaults
+
+      undotify_keys(hash.select {|k,v| DEFAULTS.has_key?(k) })
+    end
+    alias to_h to_hash
+
+    # Internal Helpers
+
+
+    def logger
+      init_logging! unless @logger
+      @logger
+    end
+
+    def backend
+      init_backend! unless @backend
+      @backend
+    end
+
+    def backend=(backend)
+      set(:backend, backend)
+      @backend = nil
+    end
+
+    def dev?
+      self[:env] && Array(self[:development_environments]).include?(self[:env])
+    end
+
+    def warn_development?
+      dev? && backend.kind_of?(Backend::Null)
+    end
+
+    def public?
+      return true if self[:report_data]
+      return false if self[:report_data] == false
+
+      !self[:env] || !dev?
+    end
+
+    def debug?
+      !!self[:debug]
+    end
+
+    def log_debug?
+      return debug? if self[:'logging.debug'].nil?
+
+      !!self[:'logging.debug']
+    end
+
+    def ignored_classes
+      ignore_only = get(:'exceptions.ignore_only')
+      return ignore_only if ignore_only
+      return DEFAULTS[:'exceptions.ignore'] unless ignore = get(:'exceptions.ignore')
+
+      DEFAULTS[:'exceptions.ignore'] | Array(ignore)
+    end
+
+    def ca_bundle_path
+      if self[:'connection.system_ssl_cert_chain'] && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        OpenSSL::X509::DEFAULT_CERT_FILE
+      elsif self[:'connection.ssl_ca_bundle_path']
+        self[:'connection.ssl_ca_bundle_path']
+      else
+        local_cert_path
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join('..', '..', '..', 'resources', 'ca-bundle.crt'), __FILE__)
+    end
+
+    def connection_port
+      if self[:'connection.port']
+        self[:'connection.port']
+      elsif self[:'connection.secure']
+        443
+      else
+        80
+      end
+    end
+
+    def connection_protocol
+      if self[:'connection.secure']
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def max_queue_size
+      self[:max_queue_size]
+    end
+
+    def params_filters
+      Array(self[:'request.filter_keys'])
+    end
+
+    def excluded_request_keys
+      [].tap do |keys|
+        keys << :session  if self[:'request.disable_session']
+        keys << :params   if self[:'request.disable_params']
+        keys << :cgi_data if self[:'request.disable_environment']
+        keys << :url      if self[:'request.disable_url']
+      end
+    end
+
+    def log_level(key = :'logging.level')
+      case self[key].to_s
+      when /\A(0|debug)\z/i then Logger::DEBUG
+      when /\A(1|info)\z/i  then Logger::INFO
+      when /\A(2|warn)\z/i  then Logger::WARN
+      when /\A(3|error)\z/i then Logger::ERROR
+      else
+        Logger::INFO
+      end
+    end
+
+    def load_plugin?(name)
+      return false if includes_token?(self[:'skipped_plugins'], name)
+      return true unless self[:plugins].kind_of?(Array)
+
+      includes_token?(self[:plugins], name)
+    end
+
+    def root_regexp
+      return @root_regexp if @root_regexp
+      return nil if @no_root
+
+      root = get(:root).to_s
+      @no_root = true and return nil unless root =~ NOT_BLANK
+
+      @root_regexp = Regexp.new("^#{ Regexp.escape(root) }")
+    end
+
+    def detected_framework
+      if self[:framework] =~ NOT_BLANK
+        self[:framework].to_sym
+      elsif defined?(::Rails::VERSION) && ::Rails::VERSION::STRING > '3.0'
+        :rails
+      elsif defined?(::Sinatra::VERSION)
+        :sinatra
+      elsif defined?(::Rack.release)
+        :rack
+      else
+        :ruby
+      end
+    end
+
+    def framework_name
+      case detected_framework
+      when :rails then "Rails #{::Rails::VERSION::STRING}"
+      when :sinatra then "Sinatra #{::Sinatra::VERSION}"
+      when :rack then "Rack #{::Rack.release}"
+      else
+        "Ruby #{RUBY_VERSION}"
+      end
+    end
+
+    private
+
+    def detect_revision!
+      return if self[:revision]
+
+      set(:revision, Util::Revision.detect(self[:root]))
+    end
+
+    def log_path
+      return if log_stdout?
+      return if !self[:'logging.path']
+
+      locate_absolute_path(self[:'logging.path'], self[:root])
+    end
+
+    def config_path
+      config_paths.first
+    end
+
+    def config_paths
+      Array(ENV['HONEYBADGER_CONFIG_PATH'] || get(:'config.path')).map do |c|
+        locate_absolute_path(c, self[:root])
+      end
+    end
+
+    def default_backend
+      return Backend::Server.new(self) if public?
+
+      Backend::Null.new(self)
+    end
+
+    def init_backend!
+      if self[:backend].is_a?(String) || self[:backend].is_a?(Symbol)
+        @backend = Backend.for(self[:backend].to_sym).new(self)
+        return
+      end
+
+      if ruby[:backend].respond_to?(:notify)
+        @backend = ruby[:backend]
+        return
+      end
+
+      if ruby[:backend]
+        logger.warn(sprintf('Unknown backend: %p; default will be used. Backend must respond to #notify', self[:backend]))
+      end
+
+      @backend = default_backend
+    end
+
+    def build_stdout_logger
+      logger = Logger.new($stdout)
+      logger.formatter = lambda do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+      logger.level = log_level
+      Logging::FormattedLogger.new(logger)
+    end
+
+    def build_file_logger(path)
+      Logger.new(path).tap do |logger|
+        logger.level = log_level
+        logger.formatter = Logger::Formatter.new
+      end
+    end
+
+    def log_stdout?
+      self[:'logging.path'] && self[:'logging.path'].to_s.downcase == 'stdout'
+    end
+
+    def build_logger
+      return ruby[:logger] if ruby[:logger]
+
+      return build_stdout_logger if log_stdout?
+
+      if path = log_path
+        FileUtils.mkdir_p(path.dirname) unless path.dirname.writable?
+        return build_file_logger(path)
+      end
+
+      return framework[:logger] if framework[:logger]
+
+      Logger.new(nil)
+    end
+
+    def init_logging!
+      @logger = Logging::ConfigLogger.new(self, build_logger)
+    end
+
+    # Takes an Array and a value and returns true if the value exists in the
+    # array in String or Symbol form, otherwise false.
+    def includes_token?(obj, value)
+      return false unless obj.kind_of?(Array)
+
+      obj.map(&:to_sym).include?(value.to_sym)
+    end
+
+    def locate_absolute_path(path, root)
+      path = Pathname.new(path.to_s)
+      if path.absolute?
+        path
+      else
+        Pathname.new(root.to_s).join(path.to_s)
+      end
+    end
+
+    def load_config_from_disk
+      if (path = config_paths.find(&:exist?)) && path.file?
+        Yaml.new(path, self[:env]).tap do |yml|
+          yield(yml) if block_given?
+        end
+      end
+    end
+
+    def undotify_keys(hash)
+      {}.tap do |new_hash|
+        hash.each_pair do |k,v|
+          if k.to_s =~ DOTTED_KEY
+            new_hash[$1] ||= {}
+            new_hash[$1] = undotify_keys(new_hash[$1].merge({$2 => v}))
+          else
+            new_hash[k.to_s] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datumfactory/util/http.rb

@@ -0,0 +1,89 @@
+require 'forwardable'
+require 'net/http'
+require 'json'
+require 'zlib'
+require 'openssl'
+
+require 'datumfactory/version'
+
+module Datumfactory
+  module Util
+    class HTTP
+      extend Forwardable
+
+      HEADERS = {
+        'Content-type'.freeze => 'application/json'.freeze,
+        'Content-Encoding'.freeze => 'deflate'.freeze,
+        'Accept'.freeze => 'text/json, application/json'.freeze,
+        'User-Agent'.freeze => "HB-Ruby #{VERSION}; #{RUBY_VERSION}; #{RUBY_PLATFORM}".freeze
+      }.freeze
+
+      ERRORS = [Timeout::Error,
+                Errno::EINVAL,
+                Errno::ECONNRESET,
+                Errno::ECONNREFUSED,
+                Errno::ENETUNREACH,
+                EOFError,
+                Net::HTTPBadResponse,
+                Net::HTTPHeaderSyntaxError,
+                Net::ProtocolError,
+                OpenSSL::SSL::SSLError,
+                SocketError].freeze
+
+      def initialize(config)
+        @config = config
+      end
+
+      def get(endpoint)
+        response = http_connection.get(endpoint)
+        debug { format('http method=GET path=%s code=%d', endpoint.dump, response.code) }
+        response
+      end
+
+      def post(endpoint, payload, headers = nil)
+        response = http_connection.post(endpoint, compress(payload.to_json), http_headers(headers))
+        debug { format('http method=POST path=%s code=%d', endpoint.dump, response.code) }
+        response
+      end
+
+      private
+
+      attr_reader :config
+
+      def http_connection
+        setup_http_connection
+      end
+
+      def http_headers(headers = nil)
+        {}.tap do |hash|
+          hash.merge!(HEADERS)
+          hash.merge!({ 'X-API-Key' => config[:api_key].to_s })
+          hash.merge!(headers) if headers
+        end
+      end
+
+      def setup_http_connection
+        http_class = Net::HTTP::Proxy(config[:'connection.proxy_host'], config[:'connection.proxy_port'], config[:'connection.proxy_user'], config[:'connection.proxy_pass'])
+        http = http_class.new(config[:'connection.host'], config.connection_port)
+
+        http.read_timeout = config[:'connection.http_read_timeout']
+        http.open_timeout = config[:'connection.http_open_timeout']
+
+        if config[:'connection.secure']
+          http.use_ssl = true
+
+          http.ca_file = config.ca_bundle_path
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        else
+          http.use_ssl = false
+        end
+
+        http
+      end
+
+      def compress(string, level = Zlib::DEFAULT_COMPRESSION)
+        Zlib::Deflate.deflate(string, level)
+      end
+    end
+  end
+end

data/lib/datumfactory/version.rb

@@ -1,3 +1,3 @@
 module Datumfactory
-  VERSION = "0.1.0"
+  VERSION = '0.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datumfactory
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Rob Bazinet
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-21 00:00:00.000000000 Z
+date: 2021-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -32,6 +32,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -40,6 +41,10 @@ files:
 - Rakefile
 - datumfactory.gemspec
 - lib/datumfactory.rb
+- lib/datumfactory/config/defaults.rb
+- lib/datumfactory/config/yaml.rb
+- lib/datumfactory/util/config.rb
+- lib/datumfactory/util/http.rb
 - lib/datumfactory/version.rb
 homepage: https://github.com/rbazinet/datumfactory-ruby
 licenses: