akita-har_logger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c6d7e1e45f74876fef25c0840efa3b2715af8db8080411f628a7347e5d06fc9
+  data.tar.gz: 96f8b9e4f924ec89c93847bfd293ee62b1c91700f15f76e6a5fad8f525e01ad9
+SHA512:
+  metadata.gz: f9f73e60c027ab1756f3c64f4e1687cd5d43c13a938b971972d3ab8cb49252c9506b5127e04cc3207e9b8868b43d3d18992da755ce4ff98ca8a1a74e26e48915
+  data.tar.gz: 5b9f0a079665e2ce5b79052ddc375843a55144e1913fb19aa423ba355234d342188a9e242f50759f28b335776f1ccf26e985459ad08d6e6a900900380d52de76

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in akita-har_logger.gemspec
+gemspec
+
+gem "rake", "~> 13.0"

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    akita-har_logger (0.1.0)
+      json (~> 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.4.4)
+    json (2.5.1)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  akita-har_logger!
+  rake (~> 13.0)
+  rspec (~> 3.10)
+
+BUNDLED WITH
+   2.2.15

data/LICENSE

@@ -0,0 +1,201 @@
+							 Apache License
+					   Version 2.0, January 2004
+					http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+	  Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+	  stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+	  that You distribute, all copyright, patent, trademark, and
+	  attribution notices from the Source form of the Work,
+	  excluding those notices that do not pertain to any part of
+	  the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+	  distribution, then any Derivative Works that You distribute must
+	  include a readable copy of the attribution notices contained
+	  within such NOTICE file, excluding those notices that do not
+	  pertain to any part of the Derivative Works, in at least one
+	  of the following places: within a NOTICE text file distributed
+	  as part of the Derivative Works; within the Source form or
+	  documentation, if provided along with the Derivative Works; or,
+	  within a display generated by the Derivative Works, if and
+	  wherever such third-party notices normally appear. The contents
+	  of the NOTICE file are for informational purposes only and
+	  do not modify the License. You may add Your own attribution
+	  notices within Derivative Works that You distribute, alongside
+	  or as an addendum to the NOTICE text from the Work, provided
+	  that such additional attribution notices cannot be construed
+	  as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,65 @@
+# Akita HTTP Archive (HAR) logger for Rack applications
+
+This provides Rack middleware for logging HTTP request–response pairs to a HAR
+file.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'akita-har_logger'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install akita-har_logger
+
+
+## Usage
+
+To instrument your Rack application, add `Akita::HarLogger::Middleware` to the
+top of your middleware stack. For convenience, you can use
+`Akita::HarLogger.instrument`, as follows.
+
+1. In your main `application.rb`, make `Akita::HarLogger` available:
+    ```ruby
+    require 'akita/har_logger'
+    ```
+2. Add the following line to the bottom of your `Rails::Application`
+   subclass. Specifying the output file is optional; if not given, it defaults
+   to `akita_trace_{timestamp}.har`.
+   ```ruby
+   Akita::HarLogger.instrument(config, '/path/to/output/har_file.har')
+   ```
+
+Now, when you run your Rack application, all HTTP requests and responses will
+be logged to the HAR file that you've specified. You can then upload this HAR
+file to Akita for analysis.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+
+## Implementation notes
+
+References used when building this:
+  * https://ieftimov.com/post/writing-rails-middleware/
+  * https://github.com/rack/rack/blob/master/SPEC.rdoc
+  * https://w3c.github.io/web-performance/specs/HAR/Overview.html
+  * http://www.softwareishard.com/blog/har-12-spec/

data/Rakefile

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]

data/akita-har_logger.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'lib/akita/har_logger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'akita-har_logger'
+  spec.version       = Akita::HarLogger::VERSION
+  spec.authors       = ['Jed Liu']
+  spec.email         = ['jed@akitasoftware.com']
+
+  spec.summary       = 'Rails middleware for HAR logging'
+  spec.description   = 'Middleware instrumentation for logging HTTP ' \
+                       'request-response pairs to a HAR file.'
+  spec.homepage      = 'https://akitasoftware.com/'
+  spec.license       = 'Apache-2.0'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.4.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] =
+    'https://github.com/akitasoftware/akita-rails-har-logger'
+
+  # 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 'json', '~> 2.3'
+
+  spec.add_development_dependency 'rspec', '~> 3.10'
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "akita/har_logger"
+
+# 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/akita/har_logger.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'har_logger/har_entry'
+require_relative 'har_logger/version'
+require_relative 'har_logger/writer_thread'
+
+module Akita
+  module HarLogger
+    # Adds HAR-logging instrumentation to a Rails application by adding to the
+    # top of the middleware stack.
+    #
+    # Params:
+    # +config+:: the +Rails::Application::Configuration+ associated with the
+    #            Rails application being instrumented.
+    # +har_file_name:: the name of the HAR file to be produced. If the file
+    #                  exists, it will be overwritten.
+    def self.instrument(config, har_file_name = nil)
+      config.middleware.unshift(Middleware, har_file_name)
+    end
+
+    # Logs HTTP request-response pairs to a HAR file.
+    #
+    # Params:
+    # +app+:: the application to log.
+    # +out_file_name+:: the name of the HAR file to be produced. If the file
+    #                   exists, it will be overwritten.
+    class Middleware
+      def initialize(app, out_file_name = nil)
+        @app = app
+
+        if out_file_name == nil then
+          out_file_name = "akita_trace_#{Time.now.to_i}.har"
+        end
+
+        # This queue is used to ensure that event logging is thread-safe. The
+        # main thread will enqueue HarEntry objects. The HAR writer thread
+        # below dequeues these objects and writes them to the output file.
+        @entry_queue = Queue.new
+        WriterThread.new out_file_name, @entry_queue
+      end
+
+      def call(env)
+        start_time = Time.now
+        status, headers, body = @app.call(env)
+        end_time = Time.now
+
+        wait_time_ms = ((end_time.to_f - start_time.to_f) * 1000).round
+
+        @entry_queue << (HarEntry.new start_time, wait_time_ms, env, status,
+                                      headers, body)
+
+        [ status, headers, body ]
+      end
+    end
+  end
+end

data/lib/akita/har_logger/har_entry.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'http_request'
+require_relative 'http_response'
+
+module Akita
+  module HarLogger
+    # Encapsulates an HTTP request-response pair.
+    class HarEntry
+      attr_reader :request, :response
+
+      # Params:
+      # +start_time+:: a Time object representing the request's start time.
+      # +env+:: the request's HTTP environment.
+      # +status+:: the response's HTTP status code.
+      # +headers+:: the response's HTTP headers.
+      # +body+:: the response's HTTP body.
+      def initialize(start_time, wait_time_ms, env, status, headers, body)
+        @self = {
+          startedDateTime: start_time.strftime('%FT%T.%L%:z'),
+          time: wait_time_ms,
+          request: (HttpRequest.new env),
+          response: (HttpResponse.new env, status, headers, body),
+          cache: {},  # Not applicable to server-side logging.
+          timings: {
+            send: 0,  # Mandatory, but not applicable to server-side logging.
+            wait: wait_time_ms,
+            receive: 0,  # Mandatory, but not applicable to server-side logging.
+          },
+        }
+      end
+
+      def to_json(*args)
+        @self.to_json(*args)
+      end
+    end
+  end
+end

data/lib/akita/har_logger/har_utils.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Akita
+  module HarLogger
+    class HarUtils
+      # Converts a Hash into a list of Hash objects. Each entry in the given
+      # Hash will be represented in the output by a Hash object that maps
+      # 'name' to the entry's key and 'value' to the entry's value.
+      def self.hashToList(hash)
+        hash.reduce([]) { |accum, (k, v)|
+          accum.append({
+            name: k,
+            value: v,
+          })
+        }
+      end
+    end
+  end
+end

data/lib/akita/har_logger/http_request.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'har_utils'
+
+module Akita
+  module HarLogger
+    class HttpRequest
+      # Produces an HttpRequest from a request's HTTP environment.
+      def initialize(env)
+        req = Rack::Request.new env
+
+        @self = {
+          method: getMethod(env),
+          url: req.url,
+          httpVersion: getHttpVersion(env),
+          cookies: getCookies(env),
+          headers: getHeaders(env),
+          queryString: getQueryString(env),
+          headersSize: getHeadersSize(env),
+          bodySize: getBodySize(env),
+        }
+
+        # Augment with post data if we have any.
+        postData = getPostData(env)
+        if postData != nil then
+          @self[:postData] = postData
+        end
+      end
+
+      def to_json(*args)
+        @self.to_json(*args)
+      end
+
+      # Obtains the client's request method from an HTTP environment.
+      def getMethod(env)
+        (Rack::Request.new env).request_method
+      end
+
+      # Obtains the client-requested HTTP version from an HTTP environment.
+      def getHttpVersion(env)
+        # The environment doesn't have HTTP_VERSION when running with `rspec`;
+        # assume HTTP/1.1 when this happens. We don't return nil, so we can
+        # calculate the size of the headers.
+        env.key?('HTTP_VERSION') ? env['HTTP_VERSION'] : 'HTTP/1.1'
+      end
+
+      # Builds a list of cookie objects from an HTTP environment.
+      def getCookies(env)
+        req = Rack::Request::new env
+        HarUtils.hashToList req.cookies
+      end
+
+      # Builds a list of headers from an HTTP environment.
+      def getHeaders(env)
+        # HTTP headers in the environment can be identified with the "HTTP_"
+        # prefix. Filter for these. In the resulting map, rewrite keys of the
+        # form "HTTP_FOO_BAR_BAZ" into "Foo-Bar-Baz", and convert into an
+        # array.
+        HarUtils.hashToList (
+          env.select { |k,v| k.start_with? 'HTTP_' }.
+            transform_keys { |k|
+              k.sub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+            }
+        )
+      end
+
+      # Builds a list of query parameters from an HTTP environment.
+      def getQueryString(env)
+        req = Rack::Request::new env
+        paramMap = Rack::Utils.parse_nested_query req.query_string
+        HarUtils.hashToList paramMap
+      end
+
+      # Obtains the posted data from an HTTP environment.
+      def getPostData(env)
+        if env.key?('CONTENT_TYPE') && env['CONTENT_TYPE'] then
+          result = { mimeType: env['CONTENT_TYPE'] }
+
+          # Populate 'params' if we have URL-encoded parameters. Otherwise,
+          # populate 'text.
+          req = Rack::Request.new env
+          if env['CONTENT_TYPE'] == 'application/x-www-form-urlencoded' then
+            # Decoded parameters can be found as a map in req.params. Convert
+            # this map into an array.
+            #
+            # XXX Spec has space for files, but are file uploads ever
+            # URL-encoded?
+            result[:params] = HarUtils.hashToList req.params
+          else
+            result[:text] = req.body.string
+          end
+
+          result
+        else
+          nil
+        end
+      end
+
+      def getHeadersSize(env)
+        # XXX This seems to under-count, compared to a HAR produced by Firefox.
+
+        # Count the number of bytes needed to produce the first line of the
+        # request (HTTP method, full path, HTTP version, CRLF). For example,
+        #
+        #   GET /index.html?foo=bar&baz=qux HTTP/1.1<CR><LF>
+        req = Rack::Request::new env
+        line_length =
+          getMethod(env).length + 1
+            + req.fullpath.length + 1
+            + getHttpVersion(env).length + 2
+
+        # Add the size of the headers. Add 2 to the starting value to account
+        # for the CRLF on the blank line.
+        getHeaders(env).reduce(line_length + 2) { |accum, entry|
+          # Header-Name: header value<CR><LF>
+          accum + entry[:name].length + 2 + entry[:value].length + 2
+        }
+      end
+
+      # Obtains the size of the request body from an HTTP environment.
+      def getBodySize(env)
+        # Assume no content if Content-Length header was not provided.
+        env.key?('CONTENT_LENGTH') ? env['CONTENT_LENGTH'].to_i : 0
+      end
+    end
+  end
+end

data/lib/akita/har_logger/http_response.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'har_utils'
+
+module Akita
+  module HarLogger
+    class HttpResponse
+      def initialize(env, status, headers, body)
+        @self = {
+          status: status,
+          statusText: getStatusText(status),
+          httpVersion: getHttpVersion(env),
+          cookies: getCookies(headers),
+          headers: (HarUtils.hashToList headers),
+          content: getContent(headers, body),
+          redirectURL: getRedirectUrl(headers),
+          headersSize: getHeadersSize(env, status, headers),
+          bodySize: getBodySize(body),
+        }
+      end
+
+      def to_json(*args)
+        @self.to_json(*args)
+      end
+
+      # Obtains the status text corresponding to a status code.
+      def getStatusText(status)
+        Rack::Utils::HTTP_STATUS_CODES[status]
+      end
+
+      # Obtains the HTTP version in the response.
+      def getHttpVersion(env)
+        # XXX Assume the server replies with the same HTTP version as the
+        # XXX request. This seems to hold true empirically.
+
+        # The environment doesn't have HTTP_VERSION when running with `rspec`;
+        # assume HTTP/1.1 when this happens. We don't return nil, so we can
+        # calculate the size of the headers.
+        env.key?('HTTP_VERSION') ? env['HTTP_VERSION'] : 'HTTP/1.1'
+      end
+
+      def getCookies(headers)
+        result = []
+        headers.each { |k, v|
+          if "Set-Cookie".casecmp(k) != 0 then next end
+
+          # Couldn't find a great library for parsing Set-Cookie headers, so
+          # let's roll our own...
+          #
+          # According to RFC 6265, the value of Set-Cookie has the format
+          # "cookieName=cookieValue", optionally followed by a semicolon and
+          # attribute-value pairs. The cookieValue can be optionally enclosed
+          # in double quotes. Neither cookieName nor cookieValue can contain
+          # double quotes, semicolons, or equal signs.
+          match = /^([^=]*)=([^;]*)(|;.*)$/.match(v)
+          if !match then next end
+
+          cookie_name = match[1]
+          cookie_value = match[2]
+
+          # Strip quotation marks from the value if they are present.
+          match = /^"(.*)"$/.match(cookie_value)
+          if match then cookie_value = match[1] end
+
+          result << {
+            name: cookie_name,
+            value: cookie_value,
+          }
+        }
+
+        result
+      end
+
+      def getContent(headers, body)
+        # XXX Handle compression & encoding.
+
+        text = +""
+        body.each { |part|
+          # XXX Figure out how to join together multi-part bodies.
+          text << part;
+        }
+
+        {
+          size: getBodySize(body),
+
+          # XXX What to use when no Content-Type is given?
+          mimeType: headers['Content-Type'],
+
+          text: text,
+        }
+      end
+
+      def getRedirectUrl(headers)
+        # Use the "Location" header if it exists. Otherwise, based on some HAR
+        # examples found online, it looks like an empty string is used.
+        headers.key?('Location') ? headers['Location'] : ''
+      end
+
+      def getHeadersSize(env, status, headers)
+        # XXX This seems to under-count, compared to a HAR produced by Firefox.
+
+        # Count the number of bytes needed to produce the first line of the
+        # response (HTTP version, status code, status text, CRLF). For example,
+        #
+        #   HTTP/1.1 404 Not Found<CR><LF>
+        status_length =
+          getHttpVersion(env).length + 1
+            + status.to_s.length + 1
+            + getStatusText(status).length + 2
+
+        # Add the size of the headers. Add 2 to the starting value to account
+        # for the CRLF on the blank line.
+        headers.reduce(status_length + 2) { |accum, (k, v)|
+          # Header-Name: header value<CR><LF>
+          accum + k.length + 2 + v.length + 2
+        }
+      end
+
+      def getBodySize(body)
+        length = 0
+        body.each { |part| length += part.bytesize }
+        length
+      end
+    end
+  end
+end

data/lib/akita/har_logger/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Akita
+  module HarLogger
+    VERSION = "0.1.0"
+  end
+end

data/lib/akita/har_logger/writer_thread.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Akita
+  module HarLogger
+    # A thread that consumes HarEntry objects from a queue and writes them to a
+    # file.
+    #
+    # Params:
+    # +out_file_name+:: the name of the HAR file to be produced.
+    # +entry_queue+:: the queue from which to consume HAR entries.
+    class WriterThread
+      def initialize(out_file_name, entry_queue)
+        # This mutex is used to ensure the entire output is written before the
+        # application shuts down.
+        shutdown_mutex = Mutex.new
+
+        Thread.new do
+          shutdown_mutex.synchronize {
+            File.open(out_file_name, 'w') { |f|
+              # Produce a preamble.
+              f.write <<~EOF.chomp
+                {
+                  "log": {
+                    "version": "1.2",
+                    "creator": {
+                      "name": "Akita HAR logger for Ruby",
+                      "version": "1.0.0"
+                    },
+                    "entries": [
+              EOF
+
+              first_entry = true
+
+              loop do
+                entry = entry_queue.pop
+                if entry == nil then break end
+
+                # Emit comma separator if needed.
+                f.puts (first_entry ? '' : ',')
+                first_entry = false
+
+                # Emit the dequeued entry.
+                f.write JSON.generate(entry)
+              end
+
+              # Produce the epilogue.
+              f.write <<~EOF
+
+                    ]
+                  }
+                }
+              EOF
+            }
+          }
+        end
+
+        # Finish outputting the HAR file when the application shuts down.
+        at_exit do
+          # Signal to the consumer that this is the end of the entry stream and
+          # wait for the consumer to terminate.
+          entry_queue << nil
+          shutdown_mutex.synchronize {}
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: akita-har_logger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jed Liu
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+description: Middleware instrumentation for logging HTTP request-response pairs to
+  a HAR file.
+email:
+- jed@akitasoftware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- akita-har_logger.gemspec
+- bin/console
+- bin/setup
+- lib/akita/har_logger.rb
+- lib/akita/har_logger/har_entry.rb
+- lib/akita/har_logger/har_utils.rb
+- lib/akita/har_logger/http_request.rb
+- lib/akita/har_logger/http_response.rb
+- lib/akita/har_logger/version.rb
+- lib/akita/har_logger/writer_thread.rb
+homepage: https://akitasoftware.com/
+licenses:
+- Apache-2.0
+metadata:
+  homepage_uri: https://akitasoftware.com/
+  source_code_uri: https://github.com/akitasoftware/akita-rails-har-logger
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.13
+signing_key:
+specification_version: 4
+summary: Rails middleware for HAR logging
+test_files: []