opinionated_http 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21c5b626468b387d5b10f055e3f45b399d1b7c0e91a3962a31de1914f582848e
+  data.tar.gz: 4190403fda9fd6bb3853f8d552aa53f22e1ddf89ead008ee4fde7d9f184c7eaa
+SHA512:
+  metadata.gz: ff4c0ec5fadca2ac6a6cc6bbabb1e0893aa7064da3adbbfb33ef1c3561df302e2408b983ad1598360fab213ca5c35f5cc14765bcde59da95c8684d4f7f32894a
+  data.tar.gz: 274ff50c9ab8770f292ac37f2341480e01384ceddf8ef08a2ae644c139b5ecb965e0621309dd381f64e2e0a5d44bc2ee06b8037ada96c8731b8cdf645d8ab035

data/README.md

@@ -0,0 +1,19 @@
+# Opinionated HTTP
+
+An opinionated HTTP Client library using convention over configuration.
+
+Uses
+* PersistentHTTP for http connection pooling.
+* Semantic Logger for logging and metrics.
+* Secret Config for its configuration.
+
+By convention the following metrics are measured and logged:
+*
+
+PersistentHTTP with the following enhancements:
+* Read config from Secret Config, just supply the `secret_config_path`.
+* Redirect logging into standard Semantic Logger.
+* Implements metrics and measure call durations.
+* Standardized Service Exception.
+* Retries on HTTP 5XX errors
+

data/Rakefile

@@ -0,0 +1,23 @@
+# Setup bundler to avoid having to run bundle exec all the time.
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rake/testtask'
+require_relative 'lib/opinionated_http/version'
+
+task :gem do
+  system 'gem build opinionated_http.gemspec'
+end
+
+task publish: :gem do
+  system "git tag -a v#{OpinionatedHTTP::VERSION} -m 'Tagging #{OpinionatedHTTP::VERSION}'"
+  system 'git push --tags'
+  system "gem push opinionated_http-#{OpinionatedHTTP::VERSION}.gem"
+  system "rm opinionated_http-#{OpinionatedHTTP::VERSION}.gem"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = false
+end

data/lib/opinionated_http/client.rb

@@ -0,0 +1,98 @@
+require 'persistent_http'
+require 'secret_config'
+require 'semantic_logger'
+#
+# Client http implementation
+#
+module OpinionatedHTTP
+  class Client
+    attr_reader :secret_config_prefix, :logger, :metric_prefix, :error_class, :driver
+
+    def initialize(secret_config_prefix:, logger: nil, metric_prefix:, error_class:, **options)
+      @metric_prefix = metric_prefix
+      @logger        = logger || SemanticLogger[self]
+      @error_class   = error_class
+
+      internal_logger = OpinionatedHTTP::Logger.new(@logger)
+      new_options     = {
+        logger:       internal_logger,
+        debug_output: internal_logger,
+        name:         "",
+        pool_size:    SecretConfig.fetch("#{secret_config_prefix}/pool_size", type: :integer, default: 100),
+        open_timeout: SecretConfig.fetch("#{secret_config_prefix}/open_timeout", type: :float, default: 10),
+        read_timeout: SecretConfig.fetch("#{secret_config_prefix}/read_timeout", type: :float, default: 10),
+        idle_timeout: SecretConfig.fetch("#{secret_config_prefix}/idle_timeout", type: :float, default: 300),
+        keep_alive:   SecretConfig.fetch("#{secret_config_prefix}/keep_alive", type: :float, default: 300),
+        pool_timeout: SecretConfig.fetch("#{secret_config_prefix}/pool_timeout", type: :float, default: 5),
+        warn_timeout: SecretConfig.fetch("#{secret_config_prefix}/warn_timeout", type: :float, default: 0.25),
+        proxy:        SecretConfig.fetch("#{secret_config_prefix}/proxy", type: :symbol, default: :ENV),
+        force_retry:  SecretConfig.fetch("#{secret_config_prefix}/force_retry", type: :boolean, default: true),
+      }
+
+      url               = SecretConfig["#{secret_config_prefix}/url"]
+      new_options[:url] = url if url
+      @driver           = PersistentHTTP.new(new_options.merge(options))
+    end
+
+    # Perform an HTTP Get against the supplied path
+    def get(action:, path: "/#{action}", parameters: nil)
+      path = "/#{path}" unless path.start_with?("/")
+      path = "#{path}?#{URI.encode_www_form(parameters)}" if parameters
+
+      request  = Net::HTTP::Get.new(path)
+      response =
+        begin
+          payload = {}
+          if logger.trace?
+            payload[:parameters] = parameters
+            payload[:path]       = path
+          end
+          message = "HTTP GET: #{action}" if logger.debug?
+
+          logger.benchmark_info(message: message, metric: "#{metric_prefix}/#{action}", payload: payload) { driver.request(request) }
+        rescue StandardError => exc
+          message = "HTTP GET: #{action} Failure: #{exc.class.name}: #{exc.message}"
+          logger.error(message: message, metric: "#{metric_prefix}/exception", exception: exc)
+          raise(error_class, message)
+        end
+
+      unless response.is_a?(Net::HTTPSuccess)
+        message = "HTTP GET: #{action} Failure: (#{response.code}) #{response.message}"
+        logger.error(message: message, metric: "#{metric_prefix}/exception")
+        raise(error_class, message)
+      end
+
+      response.body
+    end
+
+    def post(action:, path: "/#{action}", parameters: nil)
+      path    = "/#{path}" unless path.start_with?("/")
+      request = Net::HTTP::Post.new(path)
+      request.set_form_data(*parameters) if parameters
+
+      response =
+        begin
+          payload = {}
+          if logger.trace?
+            payload[:parameters] = parameters
+            payload[:path]       = path
+          end
+          message = "HTTP POST: #{action}" if logger.debug?
+
+          logger.benchmark_info(message: message, metric: "#{metric_prefix}/#{action}", payload: payload) { driver.request(request) }
+        rescue StandardError => exc
+          message = "HTTP POST: #{action} Failure: #{exc.class.name}: #{exc.message}"
+          logger.error(message: message, metric: "#{metric_prefix}/exception", exception: exc)
+          raise(error_class, message)
+        end
+
+      unless response.is_a?(Net::HTTPSuccess)
+        message = "HTTP POST: #{action} Failure: (#{response.code}) #{response.message}"
+        logger.error(message: message, metric: "#{metric_prefix}/exception")
+        raise(error_class, message)
+      end
+
+      response.body
+    end
+  end
+end

data/lib/opinionated_http/logger.rb

@@ -0,0 +1,36 @@
+# Hack to make PersistentHTTP log to the standard logger
+# and to make it and GenePool log trace info as trace.
+module OpinionatedHTTP
+  class Logger
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def <<(message)
+      return unless logger.trace?
+
+      message = message.strip
+      return if message.blank?
+
+      logger.trace(message)
+    end
+
+    def debug(*args, &block)
+      logger.trace(*args, &block)
+    end
+
+    def info(*args, &block)
+      logger.info(*args, &block)
+    end
+
+    def warn(*args, &block)
+      logger.warn(*args, &block)
+    end
+
+    def error(*args, &block)
+      logger.error(*args, &block)
+    end
+  end
+end

data/lib/opinionated_http/version.rb

@@ -0,0 +1,3 @@
+module OpinionatedHTTP
+  VERSION = "0.0.1".freeze
+end

data/lib/opinionated_http.rb

@@ -0,0 +1,77 @@
+#
+# Opinionated HTTP
+#
+# An opinionated HTTP Client library using convention over configuration.
+#
+# Uses
+# * PersistentHTTP for http connection pooling.
+# * Semantic Logger for logging and metrics.
+# * Secret Config for its configuration.
+#
+# By convention the following metrics are measured and logged:
+# *
+#
+# PersistentHTTP with the following enhancements:
+# * Read config from Secret Config, just supply the `secret_config_path`.
+# * Redirect logging into standard Semantic Logger.
+# * Implements metrics and measure call durations.
+# * Standardized Service Exception.
+# * Retries on HTTP 5XX errors
+#
+
+require 'opinionated_http/version'
+module OpinionatedHTTP
+  autoload :Client, 'opinionated_http/client'
+  autoload :Logger, 'opinionated_http/logger'
+
+  # Create a new Opinionated HTTP instance.
+  #
+  # Parameters:
+  #   secret_config_prefix:
+  #     Required
+  #   metric_prefix:
+  #     Required
+  #   error_class:
+  #     Whenever exceptions are raised it is important that every client gets its own exception / error class
+  #     so that failures to specific http servers can be easily identified.
+  #     Required.
+  #   logger:
+  #     Default: SemanticLogger[OpinionatedHTTP]
+  #   Other options as supported by PersistentHTTP
+  #   #TODO: Expand PersistentHTTP options here
+  #
+  # Configuration:
+  #    Off of the `secret_config_path` path above, Opinionated HTTP uses specific configuration entry names
+  #    to configure the underlying HTTP setup:
+  #       url: [String]
+  #         The host url to the site to connect to.
+  #         Exclude any path, since that will be supplied when `#get` or `#post` is called.
+  #         Required.
+  #         Examples:
+  #           "https://example.com"
+  #           "https://example.com:8443/"
+  #       pool_size: [Integer]
+  #         default: 100
+  #       open_timeout: [Float]
+  #         default: 10
+  #       read_timeout: [Float]
+  #         default: 10
+  #       idle_timeout: [Float]
+  #         default: 300
+  #       keep_alive: [Float]
+  #         default: 300
+  #       pool_timeout: [Float]
+  #         default: 5
+  #       warn_timeout: [Float]
+  #         default: 0.25
+  #       proxy: [Symbol]
+  #         default: :ENV
+  #       force_retry: [true|false]
+  #         default: true
+  #
+  # Metrics:
+  #   During each call to `#get` or `#put`, the following metrics are logged using the
+  def self.new(**args)
+    Client.new(**args)
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,33 @@
+require 'net/http'
+require 'json'
+require_relative 'test_helper'
+
+module OpinionatedHTTP
+  class ClientTest < Minitest::Test
+    describe OpinionatedHTTP::Client do
+      class ServiceError < StandardError
+      end
+
+      let :http do
+        OpinionatedHTTP.new(
+          secret_config_prefix: 'fake_service',
+          metric_prefix:        'FakeService',
+          logger:               SemanticLogger["FakeService"],
+          error_class:          ServiceError,
+          header:               {'Content-Type' => 'application/json'}
+        )
+      end
+
+      describe "get" do
+        it 'success' do
+          output   = {zip: '12345', population: 54321}
+          body     = output.to_json
+          response = Net::HTTPSuccess.new(200, 'OK', body)
+          http.driver.stub(:request, response) do
+            http.get(action: 'lookup', parameters: {zip: '12345'})
+          end
+        end
+      end
+    end
+  end
+end

data/test/config/application.yml

@@ -0,0 +1,4 @@
+test:
+  fake_supplier:
+    url: https://example.org
+

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+ENV['TZ'] = 'America/New_York'
+
+require 'yaml'
+require 'minitest/autorun'
+require 'awesome_print'
+require 'secret_config'
+require 'semantic_logger'
+require 'opinionated_http'
+
+SemanticLogger.add_appender(file_name: 'test.log', formatter: :color)
+SemanticLogger.default_level = :debug
+
+SecretConfig.use :file, path: 'test', file_name: File.expand_path('config/application.yml', __dir__)

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: opinionated_http
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: persistent_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: secret_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: semantic_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: HTTP Client with retries. Uses PersistentHTTP for http connection pooling,
+  Semantic Logger for logging and metrics, and uses Secret Config for its configuration.
+email:
+- reidmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/opinionated_http.rb
+- lib/opinionated_http/client.rb
+- lib/opinionated_http/logger.rb
+- lib/opinionated_http/version.rb
+- test/client_test.rb
+- test/config/application.yml
+- test/test_helper.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Opinionated HTTP Client
+test_files:
+- test/client_test.rb
+- test/config/application.yml
+- test/test_helper.rb