httpigeon 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e9a75a860ebdb91a4efcfe5d69f7e7a04da7b6f1762b2a67fb1d9ec5aefe2cab
+  data.tar.gz: 47f3ac2004f2d716888b36febc71e411ae5afdc8d62bc1a47b536c8fa100a1e8
+SHA512:
+  metadata.gz: e8f8f90f1aa68d59f67e4c3fe51932450755c291092ba7e9baa0e8f17502d09c7adc6186c9f1c229a5b54470192dd6b0c0e4d8e4e6c69dc1dab4d051b923dfbc
+  data.tar.gz: dfd927e24af3dfc5c08d9c7e6a7a9767e5f9207b87286143b580c33f36525f24f87a9656dc133b84807f84001f9381ab380ed4dc6286444b40c1ab5f664ff59d

data/.github/PULL_REQUEST_TEMPLATE/new_feature_template.md

@@ -0,0 +1,7 @@
+[Issue](link/to/ticket)
+
+#### Description
+
+#### Testing Steps
+
+#### Notes

data/.github/workflows/ci.yaml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, reopened, edited, synchronize]
+
+jobs:
+  validate-conventional-commit:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check for conventional commit
+        uses: agenthunt/conventional-commit-checker-action@v1.0.0
+        with:
+          pr-title-regex: '^((build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\(.*\))?(!)?(: (.*\s*)*))|(^Merge (.*\s*)*)|(^Initial commit$)'
+          pr-body-regex: '.*'
+
+  unit-test:
+    runs-on: ubuntu-latest
+    if: ${{ github.event.action != 'edited' }}
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rake spec

data/.github/workflows/publish.yaml

@@ -0,0 +1,45 @@
+name: Publish
+on:
+  workflow_call:
+    inputs:
+      public_publish:
+        required: false
+        type: string
+        default: 'false'
+      private_publish:
+        required: false
+        type: string
+        default: 'false'
+jobs:
+  release:
+    name: Release gem
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1
+      - name: Publish to GitHub
+        if: inputs.private_publish == 'true'
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:github: Bearer ${GITHUB_TOKEN}\n" > $HOME/.gem/credentials
+          gem build *.gemspec
+          gem push --KEY github --host https://rubygems.pkg.github.com/dailypay *.gem
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Publish to RubyGems
+        if: inputs.public_publish == 'true'
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:rubygems_api_key: ${RUBYGEMS_API_KEY}\n" > $HOME/.gem/credentials
+          gem build *.gemspec
+          gem push *.gem
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}

data/.github/workflows/release-please.yaml

@@ -0,0 +1,26 @@
+name: release-please
+on: [pull_request]
+
+jobs:
+  release-please:
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+    permissions: write-all
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google-github-actions/release-please-action@v3
+        id: release
+        with:
+          release-type: ruby
+          package-name: httpigeon
+          bump-minor-pre-major: true
+          bump-patch-for-minor-pre-major: true
+  publish-gem:
+    uses: ./.github/workflows/publish.yaml
+    needs: [ release-please ]
+    # if: needs.release-please.outputs.release_created
+    with:
+      public_publish: 'true'
+      private_publish: 'false'
+    secrets: inherit # implicitly forward secrets to called workflow

data/.github/workflows/reviewdog.yaml

@@ -0,0 +1,19 @@
+name: Reviewdog
+on: [pull_request]
+jobs:
+  rubocop:
+    name: rubocop
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.1
+      - name: rubocop
+        uses: reviewdog/action-rubocop@v2
+        with:
+          rubocop_version: gemfile
+          rubocop_extensions: rubocop-rspec:gemfile
+          reporter: github-pr-check
+          fail_on_error: true

data/.gitignore

@@ -0,0 +1,19 @@
+## GENERAL
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+
+## BUNDLER
+*.gem
+/.bundle/
+Gemfile.lock
+vendor/bundle
+
+## IDEs
+.idea/
+.yardoc
+/.yardoc
+/_yardoc/

data/.rubocop.yml

@@ -0,0 +1,187 @@
+require:
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.1.2
+  Exclude:
+    - 'bin/**/*'
+    - 'vendor/**/*'
+  NewCops: enable
+
+#### ::STYLE ####
+
+# Let Ruby do it's thing when the time comes
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Decision whether to use alias or alias_method is not stylistic
+# See: https://blog.bigbinary.com/2012/01/08/alias-vs-alias-method.html
+Style/Alias:
+  Enabled: false
+
+# This still common in Rails and usually doesn't result in problems.
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/CollectionMethods:
+  Description: Preferred collection methods.
+  StyleGuide: https://github.com/bbatsov/ruby-style-guide#map-find-select-reduce-size
+  Enabled: true
+  PreferredMethods:
+    collect: map
+    collect!: map!
+    find: detect
+    find_all: select
+    reduce: inject
+
+# We don't enforce per-class documentation.
+Style/Documentation:
+  Enabled: false
+
+# We don't mind two-line empty methods as they're easier to start editing and
+# pretty common in auto-generated Rails controllers.
+Style/EmptyMethod:
+  Enabled: false
+
+# We allow hash rockets in rake task dependencies, e.g. task :my_task => :dep.
+Style/HashSyntax:
+  EnforcedShorthandSyntax: never
+
+# There's no statistical difference between single and double quotes
+# performance.
+# See: https://www.viget.com/articles/just-use-double-quoted-ruby-strings/
+Style/StringLiterals:
+  Enabled: false
+
+# Ditto for above.
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/BlockDelimiters:
+  AllowBracesOnProceduralOneLiners: true
+
+Style/ModuleFunction:
+  EnforcedStyle: extend_self
+
+Style/SymbolArray:
+  MinSize: 3
+
+Style/WordArray:
+  MinSize: 3
+
+Style/FetchEnvVar:
+  Enabled: false
+
+Style/OpenStructUse:
+  Enabled: false
+
+Style/RedundantInitialize:
+  Exclude:
+    - 'test/**/*.rb'
+
+Style/Semicolon:
+  Exclude:
+    - 'test/**/*.rb'
+
+Style/Lambda:
+  Enabled: false
+
+#### ::LAYOUT ####
+
+Layout/DotPosition:
+  Enabled: true
+  EnforcedStyle: trailing
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented_relative_to_receiver
+  Enabled: false
+  IndentationWidth: ~
+
+# This rule does not detect string interpolations reliably,
+# e.g. accuses 'full_messages.join(", ")'
+Layout/SpaceInsideStringInterpolation:
+  Enabled: false
+
+# Allow long lines with comments
+Layout/LineLength:
+  Max: 200
+  AllowedPatterns: ['(\A|\s)#']
+
+#### ::LINT ####
+Lint/AssignmentInCondition:
+  AllowSafeAssignment: false
+
+Lint/ConstantDefinitionInBlock:
+  Exclude:
+    - 'test/**/*.rb'
+
+#### ::METRICS ####
+
+# Methods should be easy to read, enforcing an arbitrary metric as number
+# of lines is not the way to do it though.
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+#### ::NAMING ####
+
+# Allow arbitrary symbol names
+Naming/VariableNumber:
+  CheckSymbols: false
+
+Naming/BlockForwarding:
+  Enabled: false
+
+#### ::GEM ####
+Gemspec/DevelopmentDependencies:
+  Enabled: false
+
+Gemspec/OrderedDependencies:
+  Enabled: false
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+#### ::RSPEC ####
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Max: 10
+
+RSpec/AnyInstance:
+  Enabled: false
+
+RSpec/VerifiedDoubles:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Max: 10
+
+RSpec/NestedGroups:
+  Max: 5
+
+RSpec/FilePath:
+  Exclude:
+    - spec/httpigeon/**/*.rb
+
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - spec/httpigeon/**/*.rb

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+# Changelog
+
+## [2.0.0](https://github.com/dailypay/httpigeon/compare/v1.3.0...v2.0.0) (2023-10-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* **logging:** Improve redaction mechanism ([#23](https://github.com/dailypay/httpigeon/issues/23))
+
+### Features
+
+* Generate request ID header by default ([#25](https://github.com/dailypay/httpigeon/issues/25)) ([c2aa078](https://github.com/dailypay/httpigeon/commit/c2aa078947c422f544ff1b36d77576a2a3681d08))
+* **logging:** Improve redaction mechanism ([#23](https://github.com/dailypay/httpigeon/issues/23)) ([ce090bd](https://github.com/dailypay/httpigeon/commit/ce090bd0124ef3f3ec616d7c0af5a4652be11b0a))
+
+## [1.3.0](https://github.com/dailypay/httpigeon/compare/v1.2.1...v1.3.0) (2023-08-24)
+
+
+### Features
+
+* **request:** Add helper :get and :post class methods ([#21](https://github.com/dailypay/httpigeon/issues/21)) ([e7427a6](https://github.com/dailypay/httpigeon/commit/e7427a6f1fe2d39e4cce2ec3ea1188e03b563287))
+
+## [1.2.1](https://github.com/dailypay/httpigeon/compare/v1.2.0...v1.2.1) (2023-07-28)
+
+
+### Bug Fixes
+
+* **logger:** Fix reference to ruby Logger constant ([#19](https://github.com/dailypay/httpigeon/issues/19)) ([ec99bd5](https://github.com/dailypay/httpigeon/commit/ec99bd5b6371256ded6c88c8413b0bd2c926a7a1))
+
+## [1.2.0](https://github.com/dailypay/httpigeon/compare/v1.1.1...v1.2.0) (2023-07-28)
+
+
+### Features
+
+* Add customizable log redactor that can handle both Hash and String payload. Also add support for auto-generating request IDs ([#14](https://github.com/dailypay/httpigeon/issues/14)) ([c3efa0a](https://github.com/dailypay/httpigeon/commit/c3efa0a510cda687f6a6822e17c1c9600ba4dfd0))
+
+## [1.1.1](https://github.com/dailypay/httpigeon/compare/v1.1.0...v1.1.1) (2023-06-20)
+
+
+### Bug Fixes
+
+* **httpigeon:** Leave event logger constructor signature up to call site ([#10](https://github.com/dailypay/httpigeon/issues/10)) ([03ba441](https://github.com/dailypay/httpigeon/commit/03ba441c66d8ea6562f218b41cc8f724bd98a4a9))
+
+## 1.0.0 (2023-06-20)
+Initial release
+
+### Features
+
+* **httpigeon:** [XAPI-1353] Gemify HTTPigeon library ([#1](https://github.com/dailypay/httpigeon/issues/1)) ([ee89810](https://github.com/dailypay/httpigeon/commit/ee898102b2dffe6623e57a0d799a8b9a37d068a1))

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in httpigeon-ruby.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 DailyPay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,191 @@
+# HTTPigeon
+
+As early as 2000 years ago, and as late as 20 years ago, messenger pigeons (a.k.a homing pigeons) were an established and reliable means of long distance communication. This library is dedicated to messenger pigeons and all their contributions towards ancient and modern civilization ❤️.
+
+The goal of this library is to add a layer of abstraction on top of [Faraday](https://github.com/lostisland/faraday) client with a much simpler, but also customizable interface, so that making and logging API requests is much easier.
+
+## Usage
+
+**Configuration:**
+```ruby
+HTTPigeon.configure do |config|
+  config.default_event_type = # Set a default event type for all requests, overridable per request. Default: 'http.outbound'
+  config.default_filter_keys = # Set a default list of keys to be redacted for Hash payloads, overridable per request. Default: []
+  config.redactor_string = # Set a string that should be used as the replacement when redacting sensitive data. Default: '[FILTERED]'
+  config.log_redactor = # Specify an object to be used for redacting data before logging. Must respond to #redact(data<Hash, String>). Default: nil
+  config.event_logger = # Specify an object to be used for logging request roundtrip events. Default: $stdout
+  config.auto_generate_request_id = # Auto-generate a uuid for each request and store in a 'X-Request-Id' header? Default: true
+  config.exception_notifier = # Specify an object to be used for reporting errors. Must respond to #notify_exception(e<Exception>). Must be defined if :notify_all_exceptions is true
+  config.notify_all_exceptions = # Do you want these errors to actually get reported/notified? Default: false
+end
+```
+
+**Instantiating with a block:**
+```ruby
+# @option [String] base_url the base URI (required)
+request = HTTPigeon::Request.new(base_url: 'https://dummyjson.com') do |connection|
+  # connection is an instance of Faraday::Connection
+  connection.headers['foo'] = 'barzzz'
+  connection.options['timeout'] = 15
+  ...
+end
+
+# @option [Symbol] method the HTTP verb (default: :get)
+# @option [String] path the request path (default: '/')
+# @option [Hash] payload the body (for writes) or query params (for reads) of the request (default: {})
+request.run(path: '/users/1')
+```
+
+**Instantiating with customizable arguments:**
+```ruby
+# @param base_url [String] the base URI
+# @param options [Hash] the Faraday connection options (default: {})
+# @param headers [Hash] the request headers (default: {})
+# @param adapter [Faraday::Adapter] the Faraday adapter (default: Net::HTTP)
+# @param logger [Logger] for logging request and response (default: HTTPigeon::Logger)
+# @param event_type [String] for filtering/scoping the logs (default: 'http.outbound')
+# @param log_filters [Array<Symbol, String>] specifies keys in URL, headers and body to be redacted before logging.
+#    Can define keys for both Hash and String payloads (default: [])
+request = HTTPigeon::Request.new(base_url: 'https://dummyjson.com', headers: { Accept: 'application/json' }, log_filters: [:api_key, 'access_token', '(client_id=)(\w+)'])
+request.run(path: '/users/1')
+```
+
+**Passing a custom logger:**
+
+Your custom logger must respond to `#log` and be a registered Faraday Middleware. It can optionally implement `#on_request_start` and `#on_request_finish`, if you wanted to take certain actions right before and right after a request round-trip (e.g capturing latency).
+Note that if you pass a custom logger, you would have to handle redacting sensitive keys even if you pass a `log_filters` list, unless you subclass `HTTPigeon::Logger`.
+```ruby
+# The default Rails logger is registered/recognized by Faraday
+class CustomLogger < Logger
+  # @param [Faraday::Env] env the Faraday environment instance passed from middleware
+  # @param [Hash] data additional data passed from middleware. May contain an :error object if the request was unsuccessful (default: {})
+  def log(env, data)
+    error = data.delete(:error).to_json
+
+    log_data = data.merge(
+      {
+        method: env.method,
+        headers: env.request_headers,
+        body: env.response_body,
+        error: error,
+        latency: @end_time - @start_time
+      }
+    )
+
+    super(:info, log_data.to_json)
+  end
+
+  # optional method
+  def on_request_start
+    @start_time = Time.current
+  end
+
+  # optional method
+  def on_request_finish
+    @end_time = Time.current
+  end
+end
+
+request = HTTPigeon::Request.new(base_url: 'https://dummyjson.com', logger: CustomLogger.new)
+request.run(path: '/users/1')
+```
+
+**Using the default logger:**
+
+***Event Type***
+
+The default logger always adds an `:event_type` key to the log payload that can be used as another filtering/grouping mechanism when querying logs. The default value is 'http.outbound'. To set a different value for a specific request, simply pass the key like so:
+```ruby
+HTTPigeon::Request.new(base_url: 'https://dummyjson.com', event_type: 'custom.event')
+```
+
+***Log Filters***
+
+> [!IMPORTANT]  
+> - Log filtering mechanism does partial redaction by default, unless the value is **4 characters or less**. To have a value fully redacted, you have to explicitly append a replacement to the filter, separated by a `::` (e.g `'ssn::[REDACTED]'`). 
+> - Hash log filters are case insensitive   
+> - Only ignore case regexp flag (`/i`) is currently supported for log filters and is already applied by default
+
+Prior to logging, the default logger will always run it's redactor through:
+- The full request **URL**
+- The request and response **headers**
+- the request and response **body**
+
+**Examples:**
+
+Examples assume you set `:redactor_string` in your initializer to `[REDACTED]`
+
+| Filter | Target | Pre-redaction | Post-redaction | Notes |
+| --- | --- | --- | --- | ----- |
+| `"email"` OR `:email` | Hash | `{ "email": "atuny0@sohu.com" }` | `{ "email": "atu...[REDACTED]" }` | Filters will get applied to nested objects as well. There's no limit on depth |
+| `"email::[REDACTED]"` | Hash | `{ "email": "atuny0@sohu.com" }` | `{ "email": "[REDACTED]" }` | Replacement can be whatever you want and is applied as-is |
+| `"/email/"` | Hash | `{ "email": "atuny0@sohu.com" }` | `{ "email": "atuny0@sohu.com" }` | Regex filters will not get applied to hash keys. This is a design decision to prevent bugs |
+| `"/(email=)(.*\\.[a-z]+)(&\|$)/"` | String | `https://dummyjson.com/users?email=atuny0@sohu.com` | `https://dummyjson.com/users?email=atu...[REDACTED]` | Regex filters must be in proper regex format but wrapped in a string. If no replacement is specified, [regex grouping](https://learn.microsoft.com/en-us/dotnet/standard/base-types/grouping-constructs-in-regular-expressions) MUST be used |
+| `"/email=.*\\.[a-z]+(&\|$)/::email=[REDACTED]"` | String | `https://dummyjson.com/users?email=atuny0@sohu.com` | `https://dummyjson.com/users?email=[REDACTED]` | Replacement can be whatever you want and is applied as-is. No need to use regex grouping when explicitly specifying a replacement |
+| `"(email=)(.*\\.[a-z]+)(&\|$)"` OR `"email"` | String | `https://dummyjson.com/users?email=atuny0@sohu.com` | `https://dummyjson.com/users?email=atuny0@sohu.com` | String filters must be defined in proper regex format, otherwise they will be ignored. This is a design descision to prevent bugs |
+
+There are some ready-made, tokenized filter patterns available that you can take advantage of for **URLs** and/or **URI encoded requests**:
+  - HTTPigeon::FilterPatterns::EMAIL
+  - HTTPigeon::FilterPatterns::PASSWORD
+  - HTTPigeon::FilterPatterns::USERNAME
+  - HTTPigeon::FilterPatterns::CLIENT_ID
+  - HTTPigeon::FilterPatterns::CLIENT_SECRET
+
+```ruby
+# Will truncate the value of any header or payload key matching access_token
+# Will replace the value of any header or payload key matching password with [REDACTED]
+# Will truncate the value of any request param URI encoded payload key matching client_id
+# Will replace the value of any request param URI encoded payload key matching password with [REDACTED]
+HTTPigeon::Request.new(base_url: 'https://dummyjson.com', log_filters: %w[access_token password::[REDACTED] /(client_id=)([0-9a-z]+)*/ /password=\w+/::password=[REDACTED]])
+```
+
+**Running a request:**
+
+* You can pass a block to further customize a specific request:
+```ruby
+request = HTTPigeon::Request.new(base_url: 'https://dummyjson.com')
+
+# Returns a Hash (parsed JSON) response or a String if the original response was not valid JSON
+request.run(path: '/users/1') { |request| request.headers['X-Request-Signature'] = Base64.encode64("#{method}::#{path}") }
+
+# Access the raw Faraday response
+request.response
+
+# Quickly get the response status
+request.response_status
+
+# Quickly get the raw response body
+request.response_body
+```
+* There is a convenient :get and :post class method you can use
+```ruby
+# @param endpoint [String] the URI endpoint you're trying to hit
+# @param query [Hash] the request query params (default: {})
+# @param headers [Hash] the request headers (default: {})
+# @param event_type [String] the event type for logs grouping (default: 'http.outbound')
+# @param log_filters [Array<Symbol, String>] specifies keys in URL, headers and body to be redacted before logging.
+# @return [HTTPigeon::Response] an object with attributes :request [HTTPigeon::Request], :parsed_response [Hash], and :raw_response [Faraday::Response]
+response = HTTPigeon::Request.get(endpoint, query, headers, event_type, log_filters)
+
+# @param endpoint [String] the URI endpoint you're trying to hit
+# @param payload [Hash] the request payload/body (default: {})
+# @param headers [Hash] the request headers (default: {})
+# @param event_type [String] the event type for logs grouping (default: 'http.outbound')
+# @param log_filters [Array<Symbol, String>] specifies keys in URL, headers and body to be redacted before logging.
+# @return [HTTPigeon::Response] an object with attributes :request [HTTPigeon::Request], :parsed_response [Hash], and :raw_response [Faraday::Response]
+response = HTTPigeon::Request.post(endpoint, payload, headers, event_type, log_filters)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install:local`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dailypay/httpigeon.
+
+**Making Pull Requests:**
+
+This project uses [release-please](https://github.com/google-github-actions/release-please-action) for automated releases. As such, any pull request that fails the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0-beta.4/#summary) validation will not be merged.

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = Dir.glob("spec/**/*_spec.rb")
+  task.rspec_opts = "--format documentation"
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-rspec'
+end
+
+task default: %i[spec rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "httpigeon"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/httpigeon.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "lib/httpigeon/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "httpigeon"
+  spec.version = HTTPigeon::VERSION
+  spec.authors = ["2k-joker"]
+  spec.email = ["opensource@dailypay.com"]
+  spec.licenses = ["MIT"]
+
+  spec.summary = "Simple, easy way to make and log HTTP requests and responses"
+  spec.description = "Client library that simplifies making and logging HTTP requests and responses. This library is built as an abstraction on top of the Faraday ruby client."
+  spec.homepage = "https://github.com/dailypay/#{spec.name}"
+  spec.required_ruby_version = Gem::Requirement.new("~> 3.1.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  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.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 2.7.6"
+  spec.add_dependency "activesupport", "~> 7.0.4"
+
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "rubocop", "~> 1.21"
+  spec.add_development_dependency "rubocop-rspec", "~> 2.24"
+  spec.add_development_dependency "pry", "~> 0.13.1"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/httpigeon/configuration.rb

@@ -0,0 +1,16 @@
+module HTTPigeon
+  class Configuration
+    attr_accessor :default_event_type, :default_filter_keys, :redactor_string, :log_redactor, :event_logger, :notify_all_exceptions, :exception_notifier, :auto_generate_request_id
+
+    def initialize
+      @default_event_type = 'http.outbound'
+      @default_filter_keys = []
+      @redactor_string = '[FILTERED]'
+      @log_redactor = nil
+      @event_logger = nil
+      @auto_generate_request_id = true
+      @notify_all_exceptions = false
+      @exception_notifier = nil
+    end
+  end
+end

data/lib/httpigeon/log_redactor.rb

@@ -0,0 +1,96 @@
+require "active_support/core_ext/hash"
+
+module HTTPigeon
+  class LogRedactor
+    class UnsupportedRegexpError < StandardError; end
+
+    attr_reader :log_filters
+
+    def initialize(log_filters: nil)
+      @log_filters = log_filters.to_a.map(&:to_s)
+    end
+
+    def redact(data)
+      case data
+      when Array
+        data.map { |datum| redact(datum) }
+      when String
+        redact_string(data)
+      when Hash
+        redact_hash(data)
+      else
+        data
+      end
+    end
+
+    private
+
+    def redact_value(value)
+      length = value.to_s.length
+
+      return value unless length.positive?
+
+      case length
+      when 1..4
+        HTTPigeon.redactor_string
+      when 5..16
+        "#{value.to_s[0..2]}...#{HTTPigeon.redactor_string}"
+      when 17..32
+        "#{value.to_s[0..(length / 4)]}...#{HTTPigeon.redactor_string}"
+      else
+        "#{value.to_s[0..5]}...#{HTTPigeon.redactor_string}...#{value.to_s[-6..]}"
+      end
+    end
+
+    def redact_hash(data)
+      data.to_h do |k, v|
+        filter = hash_filter_for(k)
+
+        if filter.present?
+          replacement = filter.split('::')[1].presence
+          v = replacement.present? ? replacement : redact_value(v)
+        end
+
+        if v.is_a?(Hash)
+          [k, redact_hash(v)]
+        elsif v.is_a?(Array)
+          [k, v.map { |val| redact(val) }]
+        else
+          [k, v]
+        end
+      end
+    end
+
+    def redact_string(data)
+      log_filters.each do |filter|
+        pattern, replacement = filter.split('::')
+
+        next unless pattern.match?(%r{^/.*/([guysim]*)$})
+
+        data = if replacement.present?
+                 data.gsub(regex_for(pattern), replacement)
+               else
+                 data.gsub(regex_for(pattern)) do |sub|
+                   captures = sub.match(regex_for(pattern))&.captures
+
+                   captures.present? ? captures[0] + redact_value(captures[1]) : sub
+                 end
+               end
+      end
+
+      data
+    end
+
+    def hash_filter_for(key)
+      log_filters.detect { |k| k.split('::').first.downcase == key.to_s.downcase }
+    end
+
+    def regex_for(pattern)
+      regexp_literal = (pattern.match %r{^(/)(.*)(/(i?))$}).to_a[2].to_s
+
+      raise UnsupportedRegexpError, "The specified regexp is invalid: #{pattern}. NOTE: Only ignore case (/i) is currently supported." if regexp_literal.blank?
+
+      Regexp.new(regexp_literal, Regexp::IGNORECASE)
+    end
+  end
+end

data/lib/httpigeon/logger.rb

@@ -0,0 +1,84 @@
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object/deep_dup"
+
+module HTTPigeon
+  class Logger
+    attr_reader :event_type, :log_redactor, :start_time, :end_time
+
+    def initialize(event_type: nil, log_filters: nil)
+      @event_type = event_type || HTTPigeon.default_event_type
+      @log_redactor = HTTPigeon.log_redactor || HTTPigeon::LogRedactor.new(log_filters: HTTPigeon.default_filter_keys | log_filters.to_a)
+    end
+
+    def log(faraday_env, data = {})
+      base_log_data = { event_type: event_type }
+      log_data = build_log_data(faraday_env, data).merge(base_log_data)
+
+      HTTPigeon.event_logger.nil? ? log_to_stdout(log_data) : HTTPigeon.event_logger.log(log_data)
+    rescue StandardError => e
+      HTTPigeon.exception_notifier.notify_exception(e) if HTTPigeon.notify_all_exceptions
+      raise e if ['development', 'test'].include?(ENV['RAILS_ENV'].to_s)
+    end
+
+    def on_request_start
+      @start_time = Time.current
+    end
+
+    def on_request_finish
+      @end_time = Time.current
+    end
+
+    private
+
+    def build_log_data(env, data)
+      log_data = data.deep_dup
+      request_id = env.request_headers.transform_keys(&:downcase)['x-request-id']
+      request_latency = end_time - start_time if end_time.present? && start_time.present?
+
+      log_data[:request] = {
+        method: env.method,
+        url: redact(env.url.to_s),
+        headers: redact(env.request_headers),
+        body: redact(env.request_body),
+        host: env.url.host,
+        path: env.url.path
+      }
+
+      log_data[:response] = {
+        headers: redact(env.response_headers),
+        body: redact(env.response_body),
+        status: env.status
+      }
+
+      log_data[:metadata] = {
+        latency: request_latency,
+        identifier: request_id,
+        protocol: env.url.scheme
+      }
+
+      if log_data[:error].present?
+        error = log_data.delete(:error)
+        log_data[:error] = {
+          type: error.class.name,
+          message: error.message,
+          backtrace: error.backtrace.last(10)
+        }
+      end
+
+      log_data
+    end
+
+    def redact(data)
+      return {} if data.blank?
+
+      data = JSON.parse(data) if data.is_a?(String)
+      log_redactor.redact(data)
+    rescue JSON::ParserError
+      log_redactor.redact(data)
+    end
+
+    def log_to_stdout(log_data)
+      ::Logger.new($stdout).log(1, log_data.to_json)
+    end
+  end
+end

data/lib/httpigeon/middleware/httpigeon_logger.rb

@@ -0,0 +1,37 @@
+require "faraday/middleware_registry"
+require "faraday/middleware"
+require "faraday/response"
+
+module HTTPigeon
+  module Middleware
+    class HTTPigeonLogger < Faraday::Middleware
+      def initialize(app, logger)
+        super(app)
+
+        @logger = logger
+      end
+
+      def call(env)
+        logger.on_request_start if logger.respond_to?(:on_request_start)
+
+        super
+      rescue StandardError => e
+        logger.on_request_finish if logger.respond_to?(:on_request_finish)
+        logger.log(env, { error: e })
+
+        raise e
+      end
+
+      def on_complete(env)
+        logger.on_request_finish if logger.respond_to?(:on_request_finish)
+        logger.log(env)
+      end
+
+      private
+
+      attr_reader :logger
+    end
+  end
+end
+
+Faraday::Response.register_middleware(httpigeon_logger: HTTPigeon::Middleware::HTTPigeonLogger)

data/lib/httpigeon/request.rb

@@ -0,0 +1,96 @@
+require "faraday"
+require "active_support/core_ext/hash"
+require "active_support/isolated_execution_state"
+require "active_support/core_ext/time"
+require_relative "middleware/httpigeon_logger"
+
+module HTTPigeon
+  class Request
+    class << self
+      def get(endpoint, query = {}, headers = {}, event_type = nil, log_filters = [])
+        request = new(base_url: endpoint, headers: headers, event_type: event_type, log_filters: log_filters)
+        parsed_response = request.run(method: :get, path: '', payload: query) do |req|
+          yield(req) if block_given?
+        end
+
+        HTTPigeon::Response.new(request, parsed_response, request.response)
+      end
+
+      def post(endpoint, payload, headers = {}, event_type = nil, log_filters = [])
+        request = new(base_url: endpoint, headers: headers,  event_type: event_type, log_filters: log_filters)
+        parsed_response = request.run(method: :post, path: '', payload: payload) do |req|
+          yield(req) if block_given?
+        end
+
+        HTTPigeon::Response.new(request, parsed_response, request.response)
+      end
+    end
+
+    attr_reader :connection, :response, :parsed_response
+
+    delegate :status, :body, to: :response, prefix: true
+
+    def initialize(base_url:, options: nil, headers: nil, adapter: nil, logger: nil, event_type: nil, log_filters: nil)
+      @base_url = base_url
+      @event_type = event_type
+      @log_filters = log_filters || []
+      @logger = logger || default_logger
+
+      request_headers = default_headers.merge(headers.to_h)
+      base_connection = Faraday.new(url: base_url)
+
+      @connection = if block_given?
+                      yield(base_connection) && base_connection
+                    else
+                      base_connection.tap do |faraday|
+                        faraday.headers.deep_merge!(request_headers)
+                        faraday.options.merge!(options.to_h)
+                        faraday.request :url_encoded
+                        faraday.adapter adapter || Faraday.default_adapter
+                        faraday.response :httpigeon_logger, @logger
+                      end
+                    end
+    end
+
+    def run(method: :get, path: '/', payload: {})
+      unless method.to_sym == :get
+        payload = payload.presence&.to_json
+        connection.headers['Content-Type'] = 'application/json'
+      end
+
+      @response = connection.send(method, path, payload) do |request|
+        yield(request) if block_given?
+      end
+
+      @parsed_response = parse_response || {}
+    end
+
+    private
+
+    attr_reader :path, :logger, :event_type, :log_filters
+
+    def parse_response
+      JSON.parse(response_body).with_indifferent_access
+    rescue JSON::ParserError
+      response_body.presence
+    end
+
+    def default_logger
+      HTTPigeon::Logger.new(event_type: event_type, log_filters: log_filters)
+    end
+
+    def default_headers
+      HTTPigeon.auto_generate_request_id ? { 'Accept' => 'application/json', 'X-Request-Id' => SecureRandom.uuid } : { 'Accept' => 'application/json' }
+    end
+  end
+
+  class Response
+    attr_reader :request, :parsed_response, :raw_response
+
+    def initialize(request, parsed_response, raw_response)
+      @request = request
+      @parsed_response = parsed_response
+      @raw_response = raw_response
+    end
+  end
+end

data/lib/httpigeon/version.rb

@@ -0,0 +1,3 @@
+module HTTPigeon
+  VERSION = "2.0.0".freeze
+end

data/lib/httpigeon.rb

@@ -0,0 +1,43 @@
+require "active_support/core_ext/module/delegation"
+
+require "httpigeon/configuration"
+require "httpigeon/version"
+require "httpigeon/log_redactor"
+require "httpigeon/logger"
+require "httpigeon/request"
+
+module HTTPigeon
+  extend self
+
+  module FilterPatterns
+    EMAIL = "/(?'key'(email_?(address|Address)?=))(?'value'(.*\\.[a-z]+))(&|$)/".freeze
+    PASSWORD = "/(?'key'(pass_?(w|W)?ord=))(?'value'([^&$])*)/".freeze
+    USERNAME = "/(?'key'(user_?(n|N)?ame=))(?'value'([^&$])*)/".freeze
+    CLIENT_ID = "/(?'key'(client_?(id|Id)?=))(?'value'([^&$])*)/".freeze
+    CLIENT_SECRET = "/(?'key'(client_?(s|S)?ecret=))(?'value'([^&$])*)/".freeze
+  end
+
+  delegate :default_event_type,
+           :default_filter_keys,
+           :redactor_string,
+           :log_redactor,
+           :event_logger,
+           :auto_generate_request_id,
+           :notify_all_exceptions,
+           :exception_notifier,
+           to: :configuration
+
+  def configure
+    @config = HTTPigeon::Configuration.new
+
+    yield(@config)
+
+    @config.freeze
+  end
+
+  private
+
+  def configuration
+    @configuration ||= @config || HTTPigeon::Configuration.new
+  end
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: httpigeon
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- 2k-joker
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2023-10-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.7.6
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 7.0.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.21'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.24'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.24'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.1
+description: Client library that simplifies making and logging HTTP requests and responses.
+  This library is built as an abstraction on top of the Faraday ruby client.
+email:
+- opensource@dailypay.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/PULL_REQUEST_TEMPLATE/new_feature_template.md"
+- ".github/workflows/ci.yaml"
+- ".github/workflows/publish.yaml"
+- ".github/workflows/release-please.yaml"
+- ".github/workflows/reviewdog.yaml"
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- httpigeon.gemspec
+- lib/httpigeon.rb
+- lib/httpigeon/configuration.rb
+- lib/httpigeon/log_redactor.rb
+- lib/httpigeon/logger.rb
+- lib/httpigeon/middleware/httpigeon_logger.rb
+- lib/httpigeon/request.rb
+- lib/httpigeon/version.rb
+homepage: https://github.com/dailypay/httpigeon
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dailypay/httpigeon
+  source_code_uri: https://github.com/dailypay/httpigeon
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key: 
+specification_version: 4
+summary: Simple, easy way to make and log HTTP requests and responses
+test_files: []