feat: Write an AppMap for each observed HTTP request

Author: kgilpin

lib/appmap/middleware/remote_recording.rb

@@ -2,7 +2,8 @@
 
 module AppMap
   module Middleware
-    # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests
+    # RemoteRecording adds `/_appmap/record` routes to control recordings via HTTP requests.
+    # It can also be enabled to emit an AppMap for each request.
     class RemoteRecording
       def initialize(app)
         require 'json'
@@ -21,7 +22,7 @@ def event_loop
         end
       end
 
-      def start_recording
+      def ws_start_recording
         return [ 409, 'Recording is already in progress' ] if @tracer
 
         @events = []
@@ -32,7 +33,7 @@ def start_recording
         [ 200 ]
       end
 
-      def stop_recording(req)
+      def ws_stop_recording(req)
         return [ 404, 'No recording is in progress' ] unless @tracer
 
         tracer = @tracer
@@ -75,10 +76,50 @@ def stop_recording(req)
       end
 
       def call(env)
+        # Note: Puma config is avaliable here. For example:
+        # $ env['puma.config'].final_options[:workers]
+        # 0
+
         req = Rack::Request.new(env)
         return handle_record_request(req) if req.path == '/_appmap/record'
 
-        @app.call(env)
+        start_time = Time.now
+        # Support multi-threaded web server such as Puma by recording each thread
+        # into a separate Tracer.
+        tracer = AppMap.tracing.trace(thread: Thread.current) if record_all_requests?
+
+        @app.call(env).tap do |status, headers|
+          if tracer
+            AppMap.tracing.delete(tracer)
+
+            events = tracer.events.dup.map(&:to_h)
+
+            appmap_name = "#{req.request_method} #{req.path} (#{status}) - #{start_time.strftime('%T.%L')}"
+            appmap_file_name = AppMap::Util.scenario_filename([ start_time.to_f, req.url ].join('_'))
+            output_dir = File.join(AppMap::DEFAULT_APPMAP_DIR, 'requests')
+            appmap_file_path = File.join(output_dir, appmap_file_name)
+
+            metadata = AppMap.detect_metadata
+            metadata[:name] = appmap_name
+            metadata[:timestamp] = start_time.to_f
+            metadata[:recorder] = {
+              name: 'record_requests'
+            }
+    
+            appmap = {
+              version: AppMap::APPMAP_FORMAT_VERSION,
+              classMap: AppMap.class_map(tracer.event_methods),
+              metadata: metadata,
+              events: events
+            }
+
+            FileUtils.mkdir_p(output_dir)
+            File.write(appmap_file_path, JSON.generate(appmap))
+
+            headers['AppMap-Name'] = File.expand_path(appmap_name)
+            headers['AppMap-File-Name'] = File.expand_path(appmap_file_path)
+          end
+        end
       end
 
       def recording_state
@@ -92,9 +133,9 @@ def handle_record_request(req)
           if method.eql?('GET')
             recording_state
           elsif method.eql?('POST')
-            start_recording
+            ws_start_recording
           elsif method.eql?('DELETE')
-            stop_recording(req)
+            ws_stop_recording(req)
           else
             [ 404, '' ]
           end
@@ -106,6 +147,10 @@ def html_response?(headers)
         headers['Content-Type'] && headers['Content-Type'] =~ /html/
       end
 
+      def record_all_requests?
+        ENV['APPMAP_RECORD_REQUESTS'] == 'true'
+      end
+
       def recording?
         !@event_thread.nil?
       end

lib/appmap/trace.rb

@@ -48,8 +48,8 @@ def empty?
         @tracers.empty?
       end
 
-      def trace(enable: true)
-        Tracer.new.tap do |tracer|
+      def trace(enable: true, thread: nil)
+        Tracer.new(thread_id: thread&.object_id).tap do |tracer|
           @tracers << tracer
           tracer.enable if enable
         end
@@ -64,7 +64,7 @@ def last_package_for_current_thread
       end
 
       def record_event(event, package: nil, defined_class: nil, method: nil)
-        @tracers.each do |tracer|
+        @tracers.select { |tracer| tracer.thread_id.nil? || tracer.thread_id === event.thread_id }.each do |tracer|
           tracer.record_event(event, package: package, defined_class: defined_class, method: method)
         end
       end
@@ -114,14 +114,16 @@ def record(event)
 
   class Tracer
     attr_accessor :stacks
+    attr_reader   :thread_id, :events
 
     # Records the events which happen in a program.
-    def initialize
+    def initialize(thread_id: nil)
       @events = []
       @last_package_for_thread = {}
       @methods = Set.new
       @stack_printer = StackPrinter.new if StackPrinter.enabled?
       @enabled = false
+      @thread_id = thread_id
     end
 
     def enable
@@ -143,6 +145,8 @@ def disable # :nodoc:
     def record_event(event, package: nil, defined_class: nil, method: nil)
       return unless @enabled
 
+      raise "Expected event in thread #{@thread_id}, got #{event.thread_id}" if @thread_id && @thread_id != event.thread_id 
+
       @stack_printer.record(event) if @stack_printer
       @last_package_for_thread[Thread.current.object_id] = package if package
       @events << event