readme-metrics 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00a1c3d34d8c61c9fbcaacc3914ddb3e03837ce22bd3325dbabd30ba5b4c373e
+  data.tar.gz: 34665a455715eaf423370cba89b31575dc87d53169c9bb8680f8b87a847e1704
+SHA512:
+  metadata.gz: '05980a5c1bbdb0b23d438f18c8fcb27f931e3781e2e41ce938dff13611bfc6b70d8c61c141f644d4eeb3b1381019a3eff38e52da2adeb223cd1761ba8b6e53e7'
+  data.tar.gz: 0a084c22580cc59868089773b85dec83ad295c1984ac616f1ad8a947a8914130f35c19c78bf05b8945188cddbf49882391a8375581c5f5f50d0af0531e9db2ea

data/.gitignore

@@ -0,0 +1,2 @@
+.rspec_status
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in readme-metrics.gemspec
+gemspec
+
+gem "json-schema"
+gem "rack-test"
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+gem "standard"
+gem "webmock"

data/Gemfile.lock

@@ -0,0 +1,87 @@
+PATH
+  remote: .
+  specs:
+    readme-metrics (0.1.0)
+      httparty (~> 0.18)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    ast (2.4.1)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    diff-lcs (1.4.4)
+    hashdiff (1.0.1)
+    httparty (0.18.1)
+      mime-types (~> 3.0)
+      multi_xml (>= 0.5.2)
+    json-schema (2.8.1)
+      addressable (>= 2.4)
+    mime-types (3.3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2020.0512)
+    multi_xml (0.6.0)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
+    public_suffix (4.0.5)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    regexp_parser (1.7.1)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (0.85.1)
+      parallel (~> 1.10)
+      parser (>= 2.7.0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.0.3)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
+    rubocop-performance (1.6.1)
+      rubocop (>= 0.71.0)
+    ruby-progressbar (1.10.1)
+    safe_yaml (1.0.5)
+    standard (0.4.7)
+      rubocop (~> 0.85.0)
+      rubocop-performance (~> 1.6.0)
+    unicode-display_width (1.7.0)
+    webmock (3.8.3)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  json-schema
+  rack-test
+  rake (~> 12.0)
+  readme-metrics!
+  rspec (~> 3.0)
+  standard
+  webmock
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2020, ReadMe
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# readmeio
+
+Track your API metrics within ReadMe.
+
+[![](https://d3vv6lp55qjaqc.cloudfront.net/items/1M3C3j0I0s0j3T362344/Untitled-2.png)](https://readme.io)
+
+## Installation
+
+Add it to your Gemfile
+
+`gem "readme-metrics"`
+
+## Usage
+
+`Readme::Metrics` is a Rack middleware and is compatible with all Rack-based
+apps, including Rails.
+
+When configuring the middleware, you must provide a block to tell the
+middleware how to get values for the current user. These may be values taken
+from the environment, or you may hardcode them.
+
+If you're using Warden-based authentication like Devise, you may fetch the
+current_user for a given request from the environment.
+
+### Batching requests
+
+By default, the middleware will batch requests to the ReadMe API in groups of
+10. For every 10 requests made to your application, the middleware will make a
+single request to ReadMe. If you wish to override this, provide a
+`buffer_length` option when configuring the middleware.
+
+### Sensitive Data
+
+If you have sensitive data you'd like to prevent from being sent to the Metrics
+API via headers, query params or payload bodies, you can specify a list of keys
+to filter via the `reject_params` option. Key-value pairs matching these keys
+will not be included in the request to the Metrics API.
+
+You are also able to specify a set of `allow_only` which should only be sent through.
+Any header or body values not matching these keys will be filtered out and not
+send to the API.
+
+You may only specify either `reject_params` or `allow_only` keys, not both.
+
+### Rails
+
+```ruby
+# application.rb
+require "readme/metrics"
+
+options = {
+  api_key: "YOUR_API_KEY",
+  development: false,
+  reject_params: ["not_included", "dont_send"],
+  buffer_length: 5,
+}
+
+config.middleware.use Readme::Metrics, options do |env|
+  current_user = env['warden'].authenticate(scope: :current_user)
+
+  {
+    id: current_user.id
+    label: current_user.full_name,
+    email: current_user.email
+  }
+end
+```
+
+### Rack::Builder
+
+```ruby
+Rack::Builder.new do |builder|
+  options = {
+    api_key: "YOUR_API_KEY",
+    development: false,
+    reject_params: ["not_included", "dont_send"]
+  }
+
+  builder.use Readme::Metrics, options do |env|
+    {
+      id: "my_application_id"
+      label: "My Application",
+      email: "my.application@example.com"
+    }
+  end
+  builder.run your_app
+end
+```
+
+## License
+
+[View our license here](https://github.com/readmeio/metrics-sdks/tree/master/packages/ruby/LICENSE)
+
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "readme/metrics"
+
+# 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/lib/http_request.rb

@@ -0,0 +1,84 @@
+require "rack"
+require "rack/request"
+
+class HttpRequest
+  HTTP_NON_HEADERS = [
+    Rack::HTTP_COOKIE,
+    Rack::HTTP_VERSION,
+    Rack::HTTP_HOST,
+    Rack::HTTP_PORT
+  ]
+
+  def initialize(env)
+    @request = Rack::Request.new(env)
+  end
+
+  def url
+    @request.url
+  end
+
+  def query_params
+    @request.GET
+  end
+
+  def cookies
+    @request.cookies
+  end
+
+  def http_version
+    @request.get_header(Rack::HTTP_VERSION)
+  end
+
+  def request_method
+    @request.request_method
+  end
+
+  def content_type
+    @request.content_type
+  end
+
+  def form_data?
+    @request.form_data?
+  end
+
+  def content_length
+    @request.content_length.to_i
+  end
+
+  def headers
+    @request
+      .each_header
+      .select { |key, _| http_header?(key) }
+      .to_h
+      .transform_keys { |header| normalize_header_name(header) }
+  end
+
+  def body
+    @request.body.rewind
+    content = @request.body.read
+    @request.body.rewind
+
+    content
+  end
+
+  def parsed_form_data
+    @request.POST
+  end
+
+  private
+
+  # "headers" in Rack::Request just means any key in the env. The HTTP headers
+  # are all the headers prefixed with `HTTP_` as per the spec:
+  # https://github.com/rack/rack/blob/master/SPEC.rdoc#the-environment-
+  # Other "headers" like version and host are prefixed with `HTTP_` by Rack but
+  # don't seem to be considered legit HTTP headers.
+  def http_header?(name)
+    name.start_with?("HTTP") && !HTTP_NON_HEADERS.include?(name)
+  end
+
+  # Headers like `Content-Type: application/json` come into rack like
+  # `"HTTP_CONTENT_TYPE" => "application/json"`.
+  def normalize_header_name(header)
+    header.delete_prefix("HTTP_").split("_").map(&:capitalize).join("-")
+  end
+end

data/lib/readme/errors.rb

@@ -0,0 +1,33 @@
+module Readme
+  class Errors
+    API_KEY_ERROR = "Missing API Key"
+    REJECT_PARAMS_ERROR = "The `reject_params` option must be an array of strings"
+    ALLOW_ONLY_ERROR = "The `allow_only` option must be an array of strings"
+    BUFFER_LENGTH_ERROR = "The `buffer_length` must be an Integer"
+    DEVELOPMENT_ERROR = "The `development` option must be a boolean"
+
+    MISSING_BLOCK_ERROR = <<~MESSAGE
+      Missing block argument. You must provide a block when configuring the
+      middleware. The block must return a hash containing user info:
+        use Readme::Metrics, options do |env|
+          { id: "unique_id", label: "Your user label", email: "Your user email" }
+        end
+    MESSAGE
+
+    def self.bad_block_message(result)
+      <<~MESSAGE
+        The request could not be sent to Readme. Something went wrong when
+        setting user info. Double check the block configured on the ReadMe
+        middleware.
+
+        Expected a hash with the shape:
+          { id: "unique_id", label: "Your user label", email: "Your user email" }
+
+        Received value:
+          #{result}
+      MESSAGE
+    end
+
+    class ConfigurationError < StandardError; end
+  end
+end

data/lib/readme/filter.rb

@@ -0,0 +1,46 @@
+class Filter
+  def self.for(reject: nil, allow_only: nil)
+    if !reject.nil? && !allow_only.nil?
+      raise FilterArgsError
+    elsif !reject.nil?
+      RejectParams.new(reject)
+    elsif !allow_only.nil?
+      AllowOnly.new(allow_only)
+    else
+      None.new
+    end
+  end
+
+  class AllowOnly
+    def initialize(filter_values)
+      @filter_values = filter_values
+    end
+
+    def filter(hash)
+      hash.select { |key, _value| @filter_values.include?(key) }
+    end
+  end
+
+  class RejectParams
+    def initialize(filter_values)
+      @filter_values = filter_values
+    end
+
+    def filter(hash)
+      hash.reject { |key, _value| @filter_values.include?(key) }
+    end
+  end
+
+  class None
+    def filter(hash)
+      hash
+    end
+  end
+
+  class FilterArgsError < StandardError
+    def initialize
+      msg = "Can only supply either reject_params or allow_only, not both."
+      super(msg)
+    end
+  end
+end

data/lib/readme/har/collection.rb

@@ -0,0 +1,24 @@
+module Readme
+  module Har
+    class Collection
+      def initialize(filter, hash)
+        @filter = filter
+        @hash = hash
+      end
+
+      def to_h
+        filtered_hash
+      end
+
+      def to_a
+        filtered_hash.map { |name, value| {name: name, value: value} }
+      end
+
+      private
+
+      def filtered_hash
+        @filter.filter(@hash)
+      end
+    end
+  end
+end

data/lib/readme/har/request_serializer.rb

@@ -0,0 +1,56 @@
+require "readme/har/collection"
+require "readme/filter"
+
+module Readme
+  module Har
+    class RequestSerializer
+      def initialize(request, filter = Filter::None.new)
+        @request = request
+        @filter = filter
+      end
+
+      def as_json
+        {
+          method: @request.request_method,
+          queryString: Har::Collection.new(@filter, @request.query_params).to_a,
+          url: @request.url,
+          httpVersion: @request.http_version,
+          headers: Har::Collection.new(@filter, @request.headers).to_a,
+          cookies: Har::Collection.new(@filter, @request.cookies).to_a,
+          postData: postData,
+          headersSize: -1,
+          bodySize: @request.content_length
+        }.compact
+      end
+
+      private
+
+      def postData
+        if @request.content_type.nil?
+          nil
+        elsif @request.form_data?
+          {
+            params: form_encoded_body,
+            mimeType: @request.content_type
+          }
+        else
+          {
+            text: request_body,
+            mimeType: @request.content_type
+          }
+        end
+      end
+
+      def form_encoded_body
+        Har::Collection.new(@filter, @request.parsed_form_data).to_a
+      end
+
+      def request_body
+        parsed_body = JSON.parse(@request.body)
+        Har::Collection.new(@filter, parsed_body).to_h.to_json
+      rescue
+        @request.body
+      end
+    end
+  end
+end

data/lib/readme/har/response_serializer.rb

@@ -0,0 +1,80 @@
+require "rack/utils"
+require "readme/har/collection"
+
+module Readme
+  module Har
+    class ResponseSerializer
+      JSON_MIME_TYPES = ["application/json", "application/x-json", "text/json", "text/x-json", "+json"]
+
+      def initialize(request, response, filter)
+        @request = request
+        @response = response
+        @filter = filter
+      end
+
+      def as_json
+        {
+          status: @response.status,
+          statusText: Rack::Utils::HTTP_STATUS_CODES[@response.status],
+          httpVersion: @request.http_version,
+          headers: Har::Collection.new(@filter, @response.headers).to_a,
+          content: content,
+          redirectURL: @response.location.to_s,
+          headersSize: -1,
+          bodySize: @response.content_length,
+          cookies: Har::Collection.new(@filter, @request.cookies).to_a
+        }
+      end
+
+      private
+
+      def content
+        if response_body.nil?
+          empty_content
+        elsif content_type_is_json?
+          json_content
+        else
+          pass_through_content
+        end
+      end
+
+      def empty_content
+        {mimeType: "", size: 0}
+      end
+
+      def json_content
+        parsed_body = JSON.parse(response_body)
+
+        {mimeType: @response.content_type,
+         size: @response.content_length,
+         text: Har::Collection.new(@filter, parsed_body).to_h.to_json}
+      rescue
+        pass_through_content
+      end
+
+      def pass_through_content
+        {mimeType: @response.content_type,
+         size: @response.content_length,
+         text: response_body}
+      end
+
+      def response_body
+        if @response.body.nil?
+          nil
+        elsif @response.body.respond_to?(:rewind)
+          @response.body.rewind
+          body = @response.body.each.reduce(:+)
+          @response.body.rewind
+
+          body
+        else
+          @response.body.each.reduce(:+)
+        end
+      end
+
+      def content_type_is_json?
+        JSON_MIME_TYPES.include? @response.content_type
+      end
+    end
+  end
+end

data/lib/readme/har/serializer.rb

@@ -0,0 +1,74 @@
+require "rack"
+require "http_request"
+require "readme/metrics"
+require "readme/har/request_serializer"
+require "readme/har/response_serializer"
+require "readme/har/collection"
+
+module Readme
+  module Har
+    class Serializer
+      HAR_VERSION = "1.2"
+
+      def initialize(env, response, start_time, end_time, filter)
+        @http_request = HttpRequest.new(env)
+        @response = response
+        @start_time = start_time
+        @end_time = end_time
+        @filter = filter
+      end
+
+      def to_json
+        {
+          log: {
+            version: HAR_VERSION,
+            creator: creator,
+            entries: entries
+          }
+        }.to_json
+      end
+
+      private
+
+      def creator
+        {
+          name: Readme::Metrics::SDK_NAME,
+          version: Readme::Metrics::VERSION
+        }
+      end
+
+      def entries
+        [
+          {
+            cache: {},
+            timings: timings,
+            request: request,
+            response: response,
+            startedDateTime: @start_time.iso8601,
+            time: elapsed_time
+          }
+        ]
+      end
+
+      def timings
+        {
+          send: 0,
+          receive: 0,
+          wait: elapsed_time
+        }
+      end
+
+      def elapsed_time
+        ((@end_time - @start_time) * 1000).to_i
+      end
+
+      def request
+        Har::RequestSerializer.new(@http_request, @filter).as_json
+      end
+
+      def response
+        Har::ResponseSerializer.new(@http_request, @response, @filter).as_json
+      end
+    end
+  end
+end

data/lib/readme/metrics.rb

@@ -0,0 +1,86 @@
+require "readme/metrics/version"
+require "readme/har/serializer"
+require "readme/filter"
+require "readme/payload"
+require "readme/request_queue"
+require "readme/errors"
+require "httparty"
+
+module Readme
+  class Metrics
+    SDK_NAME = "Readme.io Ruby SDK"
+    DEFAULT_BUFFER_LENGTH = 10
+    ENDPOINT = "https://metrics.readme.io/v1/request"
+    USER_INFO_KEYS = [:id, :label, :email]
+
+    def initialize(app, options, &get_user_info)
+      validate_options(options)
+      raise Errors::ConfigurationError, Errors::MISSING_BLOCK_ERROR if get_user_info.nil?
+
+      @app = app
+      @development = options[:development] || false
+      @filter = Filter.for(
+        reject: options[:reject_params],
+        allow_only: options[:allow_only]
+      )
+      @get_user_info = get_user_info
+
+      buffer_length = options[:buffer_length] || DEFAULT_BUFFER_LENGTH
+      @@request_queue = Readme::RequestQueue.new(options[:api_key], buffer_length)
+    end
+
+    def call(env)
+      start_time = Time.now
+      status, headers, body = @app.call(env)
+      end_time = Time.now
+
+      response = Rack::Response.new(body, status, headers)
+
+      har = Har::Serializer.new(env, response, start_time, end_time, @filter)
+
+      user_info = @get_user_info.call(env)
+
+      if user_info_invalid?(user_info)
+        puts Errors.bad_block_message(user_info)
+        return [status, headers, body]
+      else
+        payload = Payload.new(har, user_info, development: @development)
+        @@request_queue.push(payload.to_json)
+      end
+
+      [status, headers, body]
+    end
+
+    private
+
+    def validate_options(options)
+      raise Errors::ConfigurationError, Errors::API_KEY_ERROR if options[:api_key].nil?
+
+      if options[:reject_params]&.any? { |param| !param.is_a? String }
+        raise Errors::ConfigurationError, Errors::REJECT_PARAMS_ERROR
+      end
+
+      if options[:allow_only]&.any? { |param| !param.is_a? String }
+        raise Errors::ConfigurationError, Errors::ALLOW_ONLY_ERROR
+      end
+
+      if options[:buffer_length] && !options[:buffer_length].is_a?(Integer)
+        raise Errors::ConfigurationError, Errors::BUFFER_LENGTH_ERROR
+      end
+
+      if options[:development] && !is_a_boolean?(options[:development])
+        raise Errors::ConfigurationError, Errors::DEVELOPMENT_ERROR
+      end
+    end
+
+    def is_a_boolean?(arg)
+      arg == true || arg == false
+    end
+
+    def user_info_invalid?(user_info)
+      user_info.nil? ||
+        user_info.values.any?(&:nil?) ||
+        USER_INFO_KEYS.sort != user_info.keys.sort
+    end
+  end
+end

data/lib/readme/metrics/version.rb

@@ -0,0 +1,5 @@
+module Readme
+  class Metrics
+    VERSION = "0.1.0"
+  end
+end

data/lib/readme/payload.rb

@@ -0,0 +1,18 @@
+module Readme
+  class Payload
+    def initialize(har, user_info, development:)
+      @har = har
+      @user_info = user_info
+      @development = development
+    end
+
+    def to_json
+      {
+        group: @user_info,
+        clientIPAddress: "1.1.1.1",
+        development: @development,
+        request: JSON.parse(@har.to_json)
+      }.to_json
+    end
+  end
+end

data/lib/readme/request_queue.rb

@@ -0,0 +1,37 @@
+require "readme/metrics"
+
+module Readme
+  class RequestQueue
+    attr_reader :queue
+
+    def initialize(api_key, buffer_length)
+      @queue = []
+      @buffer_length = buffer_length
+      @api_key = api_key
+    end
+
+    def push(request)
+      @queue << request
+
+      if ready_to_send?
+        payloads = @queue.slice!(0, @buffer_length)
+        HTTParty.post(
+          Readme::Metrics::ENDPOINT,
+          basic_auth: {username: @api_key, password: ""},
+          headers: {"Content-Type" => "application/json"},
+          body: to_json(payloads)
+        )
+      end
+    end
+
+    private
+
+    def ready_to_send?
+      @queue.length >= @buffer_length
+    end
+
+    def to_json(payloads)
+      "[#{payloads.join(", ")}]"
+    end
+  end
+end

data/readme-metrics.gemspec

@@ -0,0 +1,29 @@
+require_relative "lib/readme/metrics/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "readme-metrics"
+  spec.version = Readme::Metrics::VERSION
+  spec.authors = ["ReadMe"]
+  spec.email = ["support@readme.io"]
+  spec.license = "ISC"
+
+  spec.summary = "SDK for Readme's metrics API"
+  spec.description = "Middleware for logging requests to Readme's metrics API"
+  spec.homepage = "https://docs.readme.com/metrics/docs/getting-started-with-api-metrics"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/readmeio/metrics-sdks/blob/master/packages/ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/readmeio/metrics-sdks/blob/master/packages/ruby/CHANGELOG.md"
+
+  # 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("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  # spec.bindir        = "exe"
+  # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "httparty", "~> 0.18"
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: readme-metrics
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ReadMe
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+description: Middleware for logging requests to Readme's metrics API
+email:
+- support@readme.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/http_request.rb
+- lib/readme/errors.rb
+- lib/readme/filter.rb
+- lib/readme/har/collection.rb
+- lib/readme/har/request_serializer.rb
+- lib/readme/har/response_serializer.rb
+- lib/readme/har/serializer.rb
+- lib/readme/metrics.rb
+- lib/readme/metrics/version.rb
+- lib/readme/payload.rb
+- lib/readme/request_queue.rb
+- readme-metrics.gemspec
+homepage: https://docs.readme.com/metrics/docs/getting-started-with-api-metrics
+licenses:
+- ISC
+metadata:
+  homepage_uri: https://docs.readme.com/metrics/docs/getting-started-with-api-metrics
+  source_code_uri: https://github.com/readmeio/metrics-sdks/blob/master/packages/ruby
+  changelog_uri: https://github.com/readmeio/metrics-sdks/blob/master/packages/ruby/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: SDK for Readme's metrics API
+test_files: []