akita-har_logger 0.1.0 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c6d7e1e45f74876fef25c0840efa3b2715af8db8080411f628a7347e5d06fc9
-  data.tar.gz: 96f8b9e4f924ec89c93847bfd293ee62b1c91700f15f76e6a5fad8f525e01ad9
+  metadata.gz: 51fcd2da35cb17ecb365988d7975f746a717f12b002d3a20f1d0c3eab245b10c
+  data.tar.gz: 4972d841dfc7c8dcd41085137d45faedeb450836d46e6d3f14d584785d997a24
 SHA512:
-  metadata.gz: f9f73e60c027ab1756f3c64f4e1687cd5d43c13a938b971972d3ab8cb49252c9506b5127e04cc3207e9b8868b43d3d18992da755ce4ff98ca8a1a74e26e48915
-  data.tar.gz: 5b9f0a079665e2ce5b79052ddc375843a55144e1913fb19aa423ba355234d342188a9e242f50759f28b335776f1ccf26e985459ad08d6e6a900900380d52de76
+  metadata.gz: 8fdffa25d122a573e8c72526934e5e713fbdc573c0d4ebfa13383d749ea856f9b01d2e5bc43e89b1c152df64f97cd965ad54bd5a4ebab924d222a1829bbbec60
+  data.tar.gz: 8ca06a98ce89ec4e9c3e6ac7f3b10ec98f73c44aacab1af0bac8c81649f342ec721017ee57ff6590c93a24234cce9d40c9b341aa8277a39a59bc86a3a9c3484e

data/.gitignore

@@ -0,0 +1 @@
+/pkg/

data/Gemfile.lock

@@ -1,14 +1,12 @@
 PATH
   remote: .
   specs:
-    akita-har_logger (0.1.0)
-      json (~> 2.3)
+    akita-har_logger (0.2.4)
 
 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)
@@ -33,4 +31,4 @@ DEPENDENCIES
   rspec (~> 3.10)
 
 BUNDLED WITH
-   2.2.15
+   2.2.23

data/README.md

@@ -1,7 +1,7 @@
-# Akita HTTP Archive (HAR) logger for Rack applications
+# Akita HTTP Archive (HAR) logger for Rack/Rails applications
 
-This provides Rack middleware for logging HTTP request–response pairs to a HAR
-file.
+This provides Rack middleware and a Rails `ActionController` filter for logging
+HTTP request–response pairs to a HAR file.
 
 
 ## Installation
@@ -23,24 +23,80 @@ Or install it yourself as:
 
 ## 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.
+There are two options for instrumenting your Rack/Rails application. The first
+is to use the HAR logger as Rack middleware. The second is to use it as a Rails
+`ActionController` filter.
+
+Depending on the framework you're using, one or both options may be available
+to you. If you are interested in logging RSpec tests, the filter option will
+capture traffic for both controller and request specs, whereas the middleware
+option only captures request specs.
+
+Once your application is instrumented, when you run the application, 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.
+
+### Middleware
+
+To instrument with middleware, add `Akita::HarLogger::Middleware` to the top of
+your middleware stack. For convenience, you can call
+`Akita::HarLogger.instrument` to do this. We recommend adding this call to the
+bottom of `config/environments/test.rb` to add the middleware just to your test
+environment.
+
+Here is a sample configuration for a test environment that just adds the
+instrumentation.
+
+```ruby
+# config/environments/test.rb
+
+Rails.application.configure.do
+  # Other configuration for the Rails application...
+
+  # Put the HAR logger at the top of the middleware stack, and optionally
+  # give an output HAR file to save your trace. If not specified, this defaults
+  # to `akita_trace_{timestamp}.har`.
+  Akita::HarLogger.instrument(config, "akita_trace.har")
+end
+```
+
+### `ActionController` filter
+
+To instrument with a filter, add an instance of `Akita::HarLogger::Filter` as
+an `around_action` filter to your `ActionController` implementation.
+
+For convenience, you can call `Akita::HarLogger::Filter.install` to do this for
+all `ActionController`s in your application. We recommend adding this call to a
+configuration initializer. For example, this initializer adds the filter only
+in the test environment:
+
+```ruby
+# config/initializers/har_logging.rb
+
+# Add the HAR logger as an `around_action` filter to all `ActionControllers`
+# that are loaded by the application in the test environment. Optionally give
+# an output HAR file to save your trace. If not specified, this defaults to
+# `akita_trace_{timestamp}.har`.
+Akita::HarLogger::Filter.install("akita_trace.har") if Rails.env.test?
+```
+
+You can also selectively instrument your `ActionController` implementations by
+adding the filter manually. Here is a bare-bones `ActionController`
+implementation that adds the filter only in the test environment.
+
+```ruby
+# app/controllers/application_controller.rb
+
+class ApplicationController < ActionController::API
+  include Response
+  include ExceptionHandler
+
+  # Add the HAR logger as an `around_action` filter. Optionally give an output
+  # HAR file to save your trace. If not specified, this defaults to
+  # `akita_trace_{timestamp}.har`.
+  around_action Akita::HarLogger::Filter.new("akita_trace.har") if Rails.env.test?
+end
+```
 
 
 ## Development

data/akita-har_logger.gemspec

@@ -31,7 +31,5 @@ Gem::Specification.new do |spec|
   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/lib/akita/har_logger.rb

@@ -29,14 +29,10 @@ module Akita
         @app = app
 
         if out_file_name == nil then
-          out_file_name = "akita_trace_#{Time.now.to_i}.har"
+          out_file_name = HarLogger.default_file_name
         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
+        @entry_queue = HarLogger.get_queue(out_file_name)
       end
 
       def call(env)
@@ -52,5 +48,72 @@ module Akita
         [ status, headers, body ]
       end
     end
+
+    # Logging filter for `ActionController`s.
+    # TODO: Some amount of code duplication here. Should refactor.
+    class Filter
+      def initialize(out_file_name = nil)
+        if out_file_name == nil then
+          out_file_name = HarLogger.default_file_name
+        end
+
+        @entry_queue = HarLogger.get_queue(out_file_name)
+      end
+
+      # Registers an `on_load` initializer to add a logging filter to any
+      # ActionController that is created.
+      def self.install(out_file_name = nil, hook_name = :action_controller)
+        ActiveSupport.on_load(hook_name) do
+          around_action Filter.new(out_file_name)
+        end
+      end
+
+      # Implements the actual `around` filter.
+      def around(controller)
+        start_time = Time.now
+
+        yield
+
+        end_time = Time.now
+        wait_time_ms = ((end_time.to_f - start_time.to_f) * 1000).round
+
+        response = controller.response
+        request = response.request
+
+        @entry_queue << (HarEntry.new start_time, wait_time_ms, request.env,
+                                      response.status, response.headers,
+                                      [response.body])
+      end
+    end
+
+    @@default_file_name = "akita_trace_#{Time.now.to_i}.har"
+    def self.default_file_name
+      @@default_file_name
+    end
+
+    # Maps the name of each output file to a queue of entries to be logged to
+    # that file. The queue is used to ensure that event logging is thread-safe.
+    # The main thread will enqueue HarEntry objects. A HAR writer thread
+    # dequeues these objects and writes them to the output file.
+    @@entry_queues = {}
+    @@entry_queues_mutex = Mutex.new
+
+    # Returns the entry queue for the given file. If an entry queue doesn't
+    # already exist, one is created and a HAR writer thread is started for the
+    # queue.
+    def self.get_queue(out_file_name)
+      queue = nil
+      @@entry_queues_mutex.synchronize {
+        if @@entry_queues.has_key?(out_file_name) then
+          return @@entry_queues[out_file_name]
+        end
+
+        queue = Queue.new
+        @@entry_queues[out_file_name] = queue
+      }
+
+      WriterThread.new out_file_name, queue
+      return queue
+    end
   end
 end

data/lib/akita/har_logger/har_entry.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
 require_relative 'http_request'
 require_relative 'http_response'
 

data/lib/akita/har_logger/har_utils.rb

@@ -3,17 +3,38 @@
 module Akita
   module HarLogger
     class HarUtils
+      # Rack apparently uses 8-bit ASCII for everything, even when the string
+      # is not 8-bit ASCII. This reinterprets 8-bit ASCII strings as UTF-8.
+      def self.fixEncoding(v)
+        if v == nil || v.encoding != Encoding::ASCII_8BIT then
+          v
+        else
+          String.new(v).force_encoding(Encoding::UTF_8)
+        end
+      end
+
       # 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,
+            name: fixEncoding(k),
+            value: fixEncoding(v),
           })
         }
       end
+
+      # Determines whether all values in a Hash are strings.
+      def self.allValuesAreStrings(hash)
+        hash.each do |_, value|
+          if !(value.is_a? String) then
+            return false
+          end
+        end
+
+        return true
+      end
     end
   end
 end

data/lib/akita/har_logger/http_request.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
 require_relative 'har_utils'
 
 module Akita
@@ -12,7 +11,7 @@ module Akita
 
         @self = {
           method: getMethod(env),
-          url: req.url,
+          url: HarUtils.fixEncoding(req.url),
           httpVersion: getHttpVersion(env),
           cookies: getCookies(env),
           headers: getHeaders(env),
@@ -34,7 +33,7 @@ module Akita
 
       # Obtains the client's request method from an HTTP environment.
       def getMethod(env)
-        (Rack::Request.new env).request_method
+        HarUtils.fixEncoding (Rack::Request.new env).request_method
       end
 
       # Obtains the client-requested HTTP version from an HTTP environment.
@@ -42,7 +41,9 @@ module Akita
         # 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'
+        env.key?('HTTP_VERSION') ?
+          HarUtils.fixEncoding(env['HTTP_VERSION']) :
+          'HTTP/1.1'
       end
 
       # Builds a list of cookie objects from an HTTP environment.
@@ -72,23 +73,52 @@ module Akita
         HarUtils.hashToList paramMap
       end
 
+      # Obtains the character set of the posted data from an HTTP environment.
+      def getPostDataCharSet(env)
+        req = Rack::Request.new env
+        if req.content_charset != nil then
+          return req.content_charset
+        end
+
+        # RFC 2616 says that "text/*" defaults to ISO-8859-1.
+        if env['CONTENT_TYPE'].start_with?('text/') then
+          return Encoding::ISO_8859_1
+        end
+
+        Encoding.default_external
+      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.
+          # 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.
+            # Decoded parameters can be found as a map in req.params.
             #
-            # XXX Spec has space for files, but are file uploads ever
-            # URL-encoded?
-            result[:params] = HarUtils.hashToList req.params
+            # Requests originating from specs can be malformed: the values in
+            # req.params are not necessarily strings. Encode all of req.params
+            # in JSON and pretend the content type was "application/json".
+            if HarUtils.allValuesAreStrings req.params then
+              # Convert req.params into an array.
+              #
+              # XXX Spec has space for files, but are file uploads ever
+              # URL-encoded?
+              result[:params] = HarUtils.hashToList req.params
+            else
+              result[:mimeType] = 'application/json'
+              result[:text] = req.params.to_json
+            end
           else
-            result[:text] = req.body.string
+            # Rack has been observed to use ASCII-8BIT encoding for the request
+            # body when the request specifies UTF-8. Reinterpret the content
+            # body according to what the request says it is, and re-encode into
+            # UTF-8.
+            result[:text] = req.body.string.encode(Encoding::UTF_8,
+                getPostDataCharSet(env))
           end
 
           result

data/lib/akita/har_logger/http_response.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
 require_relative 'har_utils'
 
 module Akita
@@ -26,7 +25,7 @@ module Akita
 
       # Obtains the status text corresponding to a status code.
       def getStatusText(status)
-        Rack::Utils::HTTP_STATUS_CODES[status]
+        HarUtils.fixEncoding(Rack::Utils::HTTP_STATUS_CODES[status])
       end
 
       # Obtains the HTTP version in the response.
@@ -37,7 +36,9 @@ module Akita
         # 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'
+        env.key?('HTTP_VERSION') ?
+          HarUtils.fixEncoding(env['HTTP_VERSION']) :
+          'HTTP/1.1'
       end
 
       def getCookies(headers)
@@ -64,8 +65,8 @@ module Akita
           if match then cookie_value = match[1] end
 
           result << {
-            name: cookie_name,
-            value: cookie_value,
+            name: HarUtils.fixEncoding(cookie_name),
+            value: HarUtils.fixEncoding(cookie_value),
           }
         }
 
@@ -78,14 +79,14 @@ module Akita
         text = +""
         body.each { |part|
           # XXX Figure out how to join together multi-part bodies.
-          text << part;
+          text << (HarUtils.fixEncoding part);
         }
 
         {
           size: getBodySize(body),
 
           # XXX What to use when no Content-Type is given?
-          mimeType: headers['Content-Type'],
+          mimeType: HarUtils.fixEncoding(headers['Content-Type']),
 
           text: text,
         }
@@ -94,7 +95,9 @@ module Akita
       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'] : ''
+        headers.key?('Location') ?
+          HarUtils.fixEncoding(headers['Location']) :
+          ''
       end
 
       def getHeadersSize(env, status, headers)

data/lib/akita/har_logger/version.rb

@@ -2,6 +2,6 @@
 
 module Akita
   module HarLogger
-    VERSION = "0.1.0"
+    VERSION = "0.2.4"
   end
 end

data/lib/akita/har_logger/writer_thread.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Akita
   module HarLogger
     # A thread that consumes HarEntry objects from a queue and writes them to a

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: akita-har_logger
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.4
 platform: ruby
 authors:
 - Jed Liu
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-04-02 00:00:00.000000000 Z
+date: 2021-07-11 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
@@ -46,6 +32,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -82,7 +69,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.13
+rubygems_version: 3.2.21
 signing_key:
 specification_version: 4
 summary: Rails middleware for HAR logging