vigiles 0.1.0.pre.beta5 → 0.1.0.pre.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e4ea4b46169baf532079483c8827ee4d96f44165e3b5b1f4c021ac99a9a82bd
-  data.tar.gz: 8735c9877784c68115ea803aea9bad226d7926528208cbad19fef1f5d0d00b60
+  metadata.gz: 6ad47542ac3fa029cef8be2b99b104eb7995abf67765c8e0582426249f2d5a5a
+  data.tar.gz: a468738d5ef0ad815be016420198ef939b254997509b25228f5b3779fa51976f
 SHA512:
-  metadata.gz: 8d8d94f910b17027a7db1776db0f1ec84b197a2a47e64de039cfab327af8d59cbfd7037ada8fa403f2c04cf4ef2f7697cb206da86529deab44d4f90bb7c92919
-  data.tar.gz: 0ed649f1d6fe5ef184d286eba622c7fbade046686bf56d7e8f0f35e06aad77820fa64c5434b64f68663537791e80ef5036c7ee228a79267463571e1319457107
+  metadata.gz: df8d3f3c5361e26b23b6a8cce014c4c55f3b15cc09f754a5ed3c34f15250360e09d6a0964ed23df5b1eb81cb87bec575198f71237fd24e1ce5f3ff201b279dc6
+  data.tar.gz: fe0759a9e54c564ee235f421dbd8c7d8cfe34378777c1c3737fb29fa152a7f277c4a94808e138ec4fb61c0ef7a619bed8b60a9d14d3059299772a3ef4c2dbcda

data/lib/core_ext/action_dispatch/request.rb

@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+module ActionDispatch
+  class Request
+    sig { returns(T::Hash[String, T.untyped]) }
+    def original_headers
+      # prefix content-type and content-length with `HTTP_` too,
+      # just for uniformity. apparently the rack specification
+      # requires content length and content type headers to not
+      # have the `HTTP_` prefix.
+      # see https://github.com/rack/rack/blob/main/SPEC.rdoc
+      #
+      @original_headers ||=
+        begin
+          original = {
+            "HTTP_CONTENT_LENGTH" => get_header("CONTENT_LENGTH"),
+            "HTTP_CONTENT_TYPE" => get_header("CONTENT_TYPE")
+          }
+
+          each_header do |header, value|
+            next unless header.start_with?("HTTP_")
+
+            original[header] = value
+          end
+
+          original.freeze
+        end
+    end
+  end
+end

data/lib/core_ext.rb

@@ -2,3 +2,4 @@
 # frozen_string_literal: true
 
 require_relative "core_ext/object"
+require_relative "core_ext/action_dispatch/request"

data/lib/vigiles/archive/parameter.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vigiles
+  module Archive
+    class Parameter < T::Struct
+      class Visibility < T::Enum
+        enums do
+          PersonallyIdentifiableInformation = new("personally_identifiable_information")
+          AuthorizationKey = new("authorization_key")
+          Password = new("password")
+        end
+      end
+
+      class Source < T::Enum
+        enums do
+          Internal = new("internal")
+          External = new("external")
+        end
+      end
+
+      const :visibility, Visibility
+      const :encrypted,  T::Boolean
+      const :source,     Source
+      const :name,       String
+    end
+  end
+end

data/lib/vigiles/archive/request.rb

@@ -37,13 +37,18 @@ module Vigiles
 
       sig { params(request: ActionDispatch::Request).returns(Request) }
       def self.from(request)
+        preferred_headers = Vigiles.specification.request_headers
+        available_headers = request.original_headers
+        recorded_headers  = (available_headers if preferred_headers.empty?)
+        recorded_headers ||= preferred_headers.to_h { |h| [h, available_headers[h]] }
+
         Request.new(
           content_type: request.content_type || (raise InvalidParameterError, "content_type"),
           user_agent: request.user_agent || "unknown_user_agent",
           timestamp: DateTime.now,
           remote_ip: IPAddr.new(request.remote_ip),
           protocol: request.protocol,
-          headers: {},
+          headers: recorded_headers,
           origin: request.origin || "unknown_origin_url",
           payload: request.body.read,
           http_method: Types::HttpMethod.deserialize(request.method),

data/lib/vigiles/archive/response.rb

@@ -1,21 +1,40 @@
-# typed: strict
+# typed: false
 # frozen_string_literal: true
 
 module Vigiles
   module Archive
     class Response < T::Struct
+      const :rack_response, Rack::Response
       const :content_type, String
       const :headers,      Types::Headers
       const :payload,      Types::Payload
       const :status,       Integer
 
-      sig { params(response: ActionDispatch::Response).returns(Response) }
-      def self.from(response)
+      sig { params(rack_response: Rack::Response).returns(Types::Payload) }
+      private_class_method def self.extract_payload(rack_response)
+        case (body = rack_response.body)
+        when Array
+          return { body: :empty_no_content } if body.empty?
+
+          { body: :not_empty_handle_later }
+        when Rack::BodyProxy
+          body_proxy = body
+          body_proxy = body_proxy.instance_variable_get(:@body) until body_proxy.is_a?(Array)
+          JSON.parse(body_proxy[0])
+        else
+          debugger
+          { body: :unknown_response_payload_type }
+        end
+      end
+
+      sig { params(res: Rack::Response).returns(Response) }
+      def self.from(res)
         Response.new(
-          content_type: response.content_type,
-          headers: response.headers.as_json,
-          payload: response.body,
-          status: response.status
+          rack_response: res,
+          content_type: res.headers["Content-Type"] || "unknown_content_type",
+          headers: res.headers.as_json,
+          payload: extract_payload(res),
+          status: res.status
         )
       end
     end

data/lib/vigiles/archive.rb

@@ -16,18 +16,17 @@ module Vigiles
       end
     end
     
-    sig { params(ad_response: ActionDispatch::Response).returns(T.nilable(Conversation)) }
-    def self.record_conversation(ad_response)
+    sig { params(req: ActionDispatch::Request, res: Rack::Response).returns(T.nilable(Conversation)) }
+    def self.record_conversation(req:, res:)
         # preferring to call `response.request` instead of preparing a new
         # request (via `ActionDispatch::Request.new(env)` and passing it
         # as an argument to this method because we can always recover the
         # specific request that elicited a given response, according to
         # https://github.com/rails/rails/blob/cacb8475a9d4373c0db437e7be4905685f03cefa/actionpack/lib/action_dispatch/http/response.rb#L53
-      ad_request = ad_response.request
-      response   = Response.from(ad_response)
-      metadata   = Metadata.from(ad_request.env)
-      request    = Request.from(ad_request)
-      extras     = Extras.from(ad_request.env)
+      response   = Response.from(res)
+      metadata   = Metadata.from(req.env)
+      request    = Request.from(req)
+      extras     = Extras.from(req.env)
 
       case (content_type = request.content_type)
       when ContentType::ApplicationJson.serialize then record_json_conversation(request:, response:, metadata:, extras:)
@@ -63,7 +62,7 @@ module Vigiles
         request_id: request.id,
         response_content_type: response.content_type,
         response_headers: response.headers,
-        response_payload: JSON.load(response.payload),
+        response_payload: response.payload,
         response_status: response.status
       )
     rescue => e

data/lib/vigiles/constants.rb

@@ -3,5 +3,19 @@
 
 module Vigiles
   module Constants
+    DEFAULT_CONTENT_TYPES = T.let(
+      Set.new(
+        %w[
+          application/json
+        ]
+      ), T::Set[String]
+    )
+
+    DEFAULT_CONTENT_TYPE_RECORDERS = T.let(
+      {
+        "application/json" => Vigiles::ConversationRecorders::ApplicationJson.instance
+      }.freeze,
+      T::Hash[String, Vigiles::ConversationRecorder]
+    )
   end
 end

data/lib/vigiles/conversation_recorder.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vigiles
+  class ConversationRecorder
+    abstract!
+
+    sig { abstract.params(response: ActionDispatch::Response).returns(Archive::Conversation) }
+    def record(response); end
+  end
+end

data/lib/vigiles/conversation_recorders/application_json.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vigiles
+  module ConversationRecorders
+    class ApplicationJson < ConversationRecorder
+      include Singleton
+
+      sig { override.params(_response: ActionDispatch::Response).returns(Archive::Conversation) }
+      def record(_response) = Archive::Conversation.new
+    end
+  end
+end

data/lib/vigiles/conversation_recorders/unknown.rb

@@ -0,0 +1,11 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Vigiles
+  module ConversationRecorders
+    class Unknown < ConversationRecorder
+      sig { override.params(_response: ActionDispatch::Response).returns(Archive::Conversation) }
+      def record(_response) = Archive::Conversation.new
+    end
+  end
+end

data/lib/vigiles/middleware/record_conversation.rb

@@ -12,20 +12,19 @@ module Vigiles
 
       sig { params(env: T.untyped).returns(T.untyped) }
       def call(env)
-        record_conversation do
-          @app.call(env)
+        req = ActionDispatch::Request.new(env)
+        record_conversation(req) do
+          @app.call(req.env)
         end
       end
 
-      sig { params(blk: T.proc.returns(T.untyped)).returns(T.untyped) }
-      private def record_conversation(&blk)
-        rack_response = blk.call
-        _, _, body    = rack_response
-        response      = body.instance_variable_get(:@response)
-        Vigiles.maybe_record_conversation(response) unless response.nil?
-        rack_response
+      sig { params(req: ActionDispatch::Request, blk: T.proc.returns(T.untyped)).returns(T.untyped) }
+      private def record_conversation(req, &blk)
+        res = Rack::Response[*blk.call]
+        Vigiles.maybe_record_conversation(req:, res:)
+        res.to_a
       ensure
-        rack_response
+        res.to_a
       end
     end
   end

data/lib/vigiles/spec.rb

@@ -3,7 +3,17 @@
 
 module Vigiles
   class Spec < T::Struct
+    const :content_type_recorders, T::Hash[String, ConversationRecorder]
+    const :request_content_types,  T::Set[String]
+    const :request_headers,        T::Set[String]
+
     sig { returns(Spec) }
-    def self.make_default_spec = Spec.new
+    def self.make_default_spec
+      Spec.new(
+        content_type_recorders: Constants::DEFAULT_CONTENT_TYPE_RECORDERS,
+        request_content_types: Constants::DEFAULT_CONTENT_TYPES,
+        request_headers: Set[]
+      )
+    end
   end
 end

data/lib/vigiles/types.rb

@@ -28,5 +28,9 @@ module Vigiles
     JsonPayload = T.type_alias { T::Hash[T.untyped, T.untyped] }
     HtmlPayload = String
     Payload     = T.type_alias { T.any(JsonPayload, HtmlPayload) }
+
+    ContentTypeRecorder = T.type_alias do
+      T::Hash[String, T.proc.params(arg0: ActionDispatch::Response).returns(Vigiles::Archive::Conversation)]
+    end
   end
 end

data/lib/vigiles/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Vigiles
-  VERSION = "0.1.0-beta5"
+  VERSION = "0.1.0-beta6"
 end

data/lib/vigiles.rb

@@ -16,19 +16,35 @@ loader.setup
 module Vigiles
   extend T::Sig
 
-  sig { params(response: ActionDispatch::Response).returns(T.nilable(Archive::Conversation)) }
-  def self.maybe_record_conversation(response)
-    return unless should_record?(response)
+  sig { returns(Vigiles::Spec) }
+  def self.specification
+    @specification ||= T.let(
+      Vigiles::Spec.make_default_spec,
+      T.nilable(Vigiles::Spec)
+    )
+  end
+
+  sig { params(spec: Vigiles::Spec).returns(Vigiles::Spec) }
+  def self.specification=(spec)
+    @specification = spec
+  end
 
-    Archive.record_conversation(response)
+  sig { params(req: ActionDispatch::Request, res: Rack::Response).returns(T.nilable(Archive::Conversation)) }
+  def self.maybe_record_conversation(req:, res:)
+    return unless should_record?(req)
+
+    Archive.record_conversation(req:, res:)
   rescue Archive::UnrecordableRequestError
     nil
   end
 
   sig { params(blk: T.untyped).void }
   def self.configure(&blk)
-    default_spec = Vigiles::Spec.make_default_spec
-    blk.call(default_spec)
+    blk.call(specification)
+
+    # TODO(yaw, 2024-06-15): ensure that the specification is valid.
+    # ensure that for every content type a recorder is configured. otherwise
+    # assign the general recorder for unknown content types.
   end
 
   sig { params(request: ActionDispatch::Request).returns(T::Boolean) }
@@ -36,10 +52,8 @@ module Vigiles
     !request.nil?
   end
 
-  sig { params(response: ActionDispatch::Response).returns(T::Boolean) }
-  private_class_method def self.should_record?(response)
-    request = response.request
-
-    content_type_match?(request)
+  sig { params(req: ActionDispatch::Request).returns(T::Boolean) }
+  private_class_method def self.should_record?(req)
+    content_type_match?(req)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vigiles
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.beta5
+  version: 0.1.0.pre.beta6
 platform: ruby
 authors:
 - Yaw Boakye
@@ -205,6 +205,7 @@ files:
 - README.md
 - Rakefile
 - lib/core_ext.rb
+- lib/core_ext/action_dispatch/request.rb
 - lib/core_ext/object.rb
 - lib/generators/templates/archive_conversation_migration.rb.erb
 - lib/generators/templates/initializer.rb
@@ -216,9 +217,13 @@ files:
 - lib/vigiles/archive/conversation.rb
 - lib/vigiles/archive/extras.rb
 - lib/vigiles/archive/metadata.rb
+- lib/vigiles/archive/parameter.rb
 - lib/vigiles/archive/request.rb
 - lib/vigiles/archive/response.rb
 - lib/vigiles/constants.rb
+- lib/vigiles/conversation_recorder.rb
+- lib/vigiles/conversation_recorders/application_json.rb
+- lib/vigiles/conversation_recorders/unknown.rb
 - lib/vigiles/middleware/record_conversation.rb
 - lib/vigiles/spec.rb
 - lib/vigiles/types.rb