logtail 0.1.20 → 0.1.21

data/lib/logtail/logger.rb

@@ -15,25 +15,30 @@ module Logtail
   #
   # @example Logging an event
   #   logger.info "Payment rejected", payment_rejected: {customer_id: customer_id, amount: 100}
+  #
+  # @example Adding context to one log line (merged into the gem's context, whose own keys win)
+  #   logger.info "Payment rejected", context: {tenant_id: tenant_id}
   class Logger < ::Logger
 
     # @private
     class Formatter
-      # Formatters get the formatted level from the logger.
+      # Formatters get the formatted level from the logger. Ruby's Logger formats UNKNOWN, and any
+      # severity it doesn't know, as "ANY".
       SEVERITY_MAP = {
         "DEBUG" => :debug,
         "INFO" => :info,
         "WARN" => :warn,
         "ERROR" => :error,
         "FATAL" => :fatal,
-        "UNKNOWN" => :unknown
+        "UNKNOWN" => :unknown,
+        "ANY" => :unknown
       }
       EMPTY_ARRAY = []
 
       private
         def build_log_entry(severity, time, progname, logged_obj)
           context_snapshot = CurrentContext.instance.snapshot
-          level = SEVERITY_MAP.fetch(severity)
+          level = SEVERITY_MAP.fetch(severity, :unknown)
           tags = extract_active_support_tagged_logging_tags.clone
 
           if logged_obj.is_a?(Event)
@@ -41,8 +46,9 @@ module Logtail
                          tags: tags)
           elsif logged_obj.is_a?(Hash)
             # Extract the tags
-            tags.push(logged_obj[:tag]) if logged_obj.key?(:tag)
-            tags.concat(logged_obj[:tags]) if logged_obj.key?(:tags)
+            tags.concat(Array(logged_obj[:tag])) if logged_obj.key?(:tag)
+            tags.concat(Array(logged_obj[:tags])) if logged_obj.key?(:tags)
+            tags.compact!
             tags.uniq!
 
             message = logged_obj[:message]
@@ -192,8 +198,6 @@ module Logtail
       Logtail::Config.instance.debug { "Logtail::Logger instantiated, level: #{level}, formatter: #{formatter.class}" }
 
       @initialized = true
-
-      at_exit { self.close }
     end
 
     # Sets a new formatted on the logger.
@@ -216,6 +220,21 @@ module Logtail
       super
     end
 
+    # Delivers what was logged so far before it returns, waiting about 5 seconds at most with
+    # the HTTP log device. Call it before a process ends with `exit!`, which skips the at_exit
+    # hook that delivers the rest, as Resque's forked job processes do.
+    #
+    # Rails calls `flush` on Rails.logger after every request (ActiveSupport::LogSubscriber.flush_all!).
+    # Waiting there would hold up every request, so that call returns right away and the lines
+    # are delivered in the background as usual.
+    def flush
+      return true if caller_locations(1, 10).any? { |location| location.base_label == "flush_all!" }
+
+      @logdev.dev.flush if @logdev && @logdev.dev.respond_to?(:flush)
+      @extra_loggers.each { |logger| logger.flush if logger.respond_to?(:flush) }
+      true
+    end
+
     # @private
     def with_context(context, &block)
       Logtail::CurrentContext.with(context, &block)
@@ -233,6 +252,12 @@ module Logtail
       super
     end
 
+    # Logs the message as an info line. ::Logger#<< writes it to the log device as it is, which
+    # the HTTP device can't deliver. Rack::CommonLogger, for example, logs requests this way.
+    def <<(msg)
+      info(msg.to_s.chomp)
+    end
+
     # Backwards compatibility with older ActiveSupport::Logger versions
     Logger::Severity.constants.each do |severity|
       class_eval(<<-EOT, __FILE__, __LINE__ + 1)

data/lib/logtail/util/non_nil_hash_builder.rb

@@ -25,7 +25,7 @@ module Logtail
       def add(k, v, options = {})
         if !v.nil?
           if options[:json_encode]
-            v = v.to_json
+            v = Util.generate_json(v)
           end
 
           if options[:limit]

data/lib/logtail/util.rb

@@ -1,7 +1,15 @@
+require "json"
+
 require "logtail/util/non_nil_hash_builder"
 
 module Logtail
   # @private
   module Util
+    # Encodes data as JSON. With ActiveSupport loaded, the data is converted with `as_json` first,
+    # so values come out as ActiveSupport's `to_json` encoded them (times in ISO 8601, NaN as
+    # null, ...), but without its encoder: with json 3, ActiveSupport 8.0 and older raise from it.
+    def self.generate_json(data)
+      ::JSON.generate(data.respond_to?(:as_json) ? data.as_json : data)
+    end
   end
 end

data/lib/logtail/version.rb

@@ -1,3 +1,3 @@
 module Logtail
-  VERSION = "0.1.20"
+  VERSION = "0.1.21"
 end

data/spec/logtail/json_encoding_spec.rb

@@ -0,0 +1,121 @@
+require "spec_helper"
+require "open3"
+
+# With json 3, ActiveSupport 8.0 and older break `to_json` called directly: ActiveSupport's
+# encoder passes `quirks_mode:` to JSON.generate, and json 3 raises on the unknown keyword.
+# Calls made by JSON.generate itself pass a JSON::State and keep working. The stub does the same
+# for the Hashes and Arrays the gem encodes (TruffleRuby can't stub it on frozen String keys).
+describe "JSON encoding when to_json raises like json 3 under ActiveSupport 8.0" do
+  let(:time) { Time.utc(2016, 9, 1, 12, 0, 0) }
+  let(:io) { StringIO.new }
+  let(:logger) { Logtail::Logger.new(io) }
+
+  before(:each) do
+    [Hash, Array].each do |klass|
+      allow_any_instance_of(klass).to receive(:to_json).and_wrap_original do |original, *args|
+        raise ArgumentError, "unknown keyword: :quirks_mode" unless args.first.is_a?(::JSON::State)
+        original.call(*args)
+      end
+    end
+  end
+
+  around(:each) do |example|
+    Timecop.freeze(time) { example.run }
+  end
+
+  it "should log with the JSONFormatter" do
+    logger.formatter = Logtail::Logger::JSONFormatter.new
+    logger.info("log message", payment: {amount: 100, tags: ["a"]})
+
+    line = JSON.parse(io.string)
+    expect(line).to include("level" => "info", "dt" => "2016-09-01T12:00:00.000000Z", "message" => "log message")
+    expect(line["payment"]).to eq("amount" => 100, "tags" => ["a"])
+  end
+
+  it "should log with the AugmentedFormatter" do
+    logger.formatter = Logtail::Logger::AugmentedFormatter.new
+    logger.info("log message", payment: {amount: 100})
+
+    expect(io.string).to start_with("log message @metadata {\"level\":\"info\",\"dt\":\"2016-09-01T12:00:00.000000Z\"")
+    expect(io.string).to include("\"payment\":{\"amount\":100}")
+  end
+
+  it "should encode a log entry" do
+    log_entry = Logtail::LogEntry.new("INFO", time, nil, "log message", {custom: {a: "b"}}, nil)
+
+    expect(JSON.parse(log_entry.to_json)).to include("level" => "INFO", "message" => "log message", "context" => {"custom" => {"a" => "b"}, "runtime" => {}})
+  end
+
+  it "should encode an event" do
+    event = Logtail::Event.new("log message", {payment: {amount: 100}})
+
+    expect(event.to_json).to eq("{\"payment\":{\"amount\":100}}")
+  end
+
+  it "should encode the backtrace of an error event" do
+    event = Logtail::Events::Error.new(name: "RuntimeError", error_message: "Boom", backtrace: ["/path/to/file1.rb:26:in `function1'"])
+
+    expect(event.backtrace_json).to eq("[\"/path/to/file1.rb:26:in `function1'\"]")
+  end
+
+  it "should encode the params of a controller call event" do
+    event = Logtail::Events::ControllerCall.new(controller: "OrdersController", action: "show", params: {"id" => "1"})
+
+    expect(event.params_json).to eq("{\"id\":\"1\"}")
+  end
+
+  it "should encode values added with json_encode" do
+    hash = Logtail::Util::NonNilHashBuilder.build { |h| h.add(:headers_json, {"Accept" => "*/*"}, json_encode: true) }
+
+    expect(hash).to eq(headers_json: "{\"Accept\":\"*/*\"}")
+  end
+end
+
+# ActiveSupport changes how the whole process encodes JSON, so these examples load it in another
+# process. It prints a log entry encoded by ActiveSupport's encoder, as LogEntry#to_json did
+# before, then by LogEntry#to_json and the JSONFormatter while that encoder raises, as it does
+# with json 3 on ActiveSupport 8.0 and older.
+describe "JSON encoding with ActiveSupport loaded" do
+  def encode_with_active_support(fields)
+    script = <<~RUBY
+      require "logger" # ActiveSupport 6.1 needs it loaded first since concurrent-ruby 1.3.5
+      require "active_support"
+      require "active_support/core_ext/object/json"
+      require "logtail"
+
+      fields = #{fields}
+      log_entry = Logtail::LogEntry.new("INFO", Time.utc(2016, 9, 1, 12), nil, "log message", nil, fields)
+      puts ActiveSupport::JSON.encode(log_entry.to_hash)
+
+      ActiveSupport::JSON.singleton_class.prepend(Module.new do
+        def encode(*)
+          raise ArgumentError, "unknown keyword: quirks_mode"
+        end
+      end)
+      puts log_entry.to_json
+      logger = Logtail::Logger.new($stdout)
+      logger.formatter = Logtail::Logger::JSONFormatter.new
+      logger.info("log message", fields)
+    RUBY
+    lib = File.expand_path("../../lib", __dir__)
+    output, error, status = Open3.capture3(RbConfig.ruby, "-rbundler/setup", "-I", lib, "-e", script)
+    expect(status.success?).to be(true), error
+    output.lines.map { |line| JSON.parse(line) }
+  end
+
+  it "should encode times and symbols as ActiveSupport did" do
+    encoded_by_active_support, encoded, logged = encode_with_active_support("{time: Time.utc(2026, 1, 2, 3, 4, 5), status: :active}")
+
+    expect(encoded).to eq(encoded_by_active_support)
+    expect(encoded).to include("time" => "2026-01-02T03:04:05.000Z", "status" => "active")
+    expect(logged).to include("level" => "info", "time" => "2026-01-02T03:04:05.000Z", "status" => "active")
+  end
+
+  it "should encode NaN and Infinity as null, as ActiveSupport did" do
+    encoded_by_active_support, encoded, logged = encode_with_active_support("{nan: Float::NAN, infinity: Float::INFINITY}")
+
+    expect(encoded).to eq(encoded_by_active_support)
+    expect(encoded).to include("nan" => nil, "infinity" => nil)
+    expect(logged).to include("level" => "info", "nan" => nil, "infinity" => nil)
+  end
+end

data/spec/logtail/log_devices/http_exit_spec.rb

@@ -0,0 +1,142 @@
+require "spec_helper"
+require "delegate"
+
+# A local ingesting server that takes 3 seconds to answer each request
+class SlowAnsweringIngestServer < LocalIngestServer
+  class SlowSocket < SimpleDelegator
+    def write(*args)
+      sleep 3
+      super
+    end
+  end
+
+  private
+
+  def serve(socket)
+    super(SlowSocket.new(socket))
+  end
+end
+
+# What the HTTP device does while the process that logs with it exits. These run logtail in a
+# real Ruby process, and count what reaches a local ingesting server.
+describe Logtail::LogDevices::HTTP, "when the process exits" do
+  let(:ingest) { LocalIngestServer.new }
+
+  after { ingest.stop }
+
+  # A local port that nothing listens on, so connecting to it is refused.
+  def unused_port
+    server = TCPServer.new("127.0.0.1", 0)
+    server.addr[1]
+  ensure
+    server.close
+  end
+
+  it "delivers a line that a thread logs while Ruby kills it at exit, without printing an error" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", #{ingest.device_options}))
+      logger.info("logged before exit")
+      started = Queue.new
+      Thread.new do
+        begin
+          started << true
+          sleep
+        ensure
+          logger.info("logged by a thread that Ruby kills at exit")
+        end
+      end
+      started.pop
+    RUBY
+
+    expect(result.stderr).not_to include("log writing failed")
+    expect(ingest.messages).to contain_exactly("logged before exit", "logged by a thread that Ruby kills at exit")
+  end
+
+  it "doesn't warn about the instance variables it uses to close, with warnings on" do
+    # Ruby 2.7 and older warn about an instance variable that is read before it's set
+    result = run_ruby(<<-RUBY)
+      $VERBOSE = true
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", #{ingest.device_options}))
+      logger.info("logged before close")
+      logger.close
+      logger.info("logged after close")
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(result.stderr).not_to match(/@(closed|late_delivery_failed|last_resp) not initialized/)
+    expect(ingest.messages).to contain_exactly("logged before close", "logged after close")
+  end
+
+  it "delivers a line that an at_exit hook logs after the device closed" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = nil
+      at_exit { logger.info("logged by an at_exit hook registered first, which runs last") }
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", #{ingest.device_options}))
+      logger.info("logged before exit")
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(ingest.messages).to contain_exactly("logged before exit", "logged by an at_exit hook registered first, which runs last")
+  end
+
+  it "waits up to 5 seconds for a slow host when it delivers lines logged after closing" do
+    slow_ingest = SlowAnsweringIngestServer.new
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", #{slow_ingest.device_options}))
+      logger.close
+      logger.info("first line after close")
+      logger.info("second line after close")
+    RUBY
+
+    # A delivery that times out would drop the second line
+    expect(result.status).to be_success, result.stderr
+    expect(slow_ingest.messages).to contain_exactly("first line after close", "second line after close")
+  ensure
+    slow_ingest.stop if slow_ingest
+  end
+
+  it "delivers a batch that the outlet takes off the queue while close checks whether it's done" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      # Widens the moment between the outlet taking a batch off the queue and counting it as in flight
+      Logtail::LogDevices::HTTP::RequestAttempt.prepend(Module.new { define_method(:attempted!) { sleep 1.5; super() } })
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", #{ingest.device_options}))
+      logger.info("logged right before exit")
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(ingest.messages).to eq(["logged right before exit"])
+  end
+
+  it "closes a device once at exit, however many loggers write to it" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      closes = 0
+      at_exit { puts "closes: " + closes.to_s }
+      Logtail::LogDevices::HTTP.prepend(Module.new { define_method(:close) { closes += 1; super() } })
+      device = Logtail::LogDevices::HTTP.new("token", #{ingest.device_options})
+      3.times { |n| Logtail::Logger.new(device).info("line " + n.to_s) }
+    RUBY
+
+    expect(result.stdout).to eq("closes: 1\n"), result.stderr
+    expect(ingest.messages).to contain_exactly("line 0", "line 1", "line 2")
+  end
+
+  it "exits within 5 seconds when the ingesting host can't be reached, however many loggers there are" do
+    result = run_ruby(<<-RUBY)
+      exiting = nil
+      at_exit { puts Process.clock_gettime(Process::CLOCK_MONOTONIC) - exiting }
+      require "logtail"
+      device = Logtail::LogDevices::HTTP.new("token", ingesting_host: "127.0.0.1", ingesting_port: #{unused_port}, ingesting_scheme: "http")
+      2.times { |n| Logtail::Logger.new(device).info("line " + n.to_s) }
+      exiting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(result.stdout.to_f).to be < 5
+  end
+end

data/spec/logtail/log_devices/http_fork_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+# Forking servers and job runners (Puma, Unicorn, Resque) fork after the app logged. These run
+# logtail in a real process that forks, and count what reaches a local ingesting server.
+describe Logtail::LogDevices::HTTP, "after a fork" do
+  let(:ingest) { LocalIngestServer.new }
+
+  before do
+    skip "needs fork" if !Process.respond_to?(:fork) || RUBY_ENGINE == "truffleruby"
+  end
+
+  after { ingest.stop }
+
+  it "delivers the lines the parent logged before forking once, not once per process" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", flush_interval: 60, #{ingest.device_options}))
+      logger.info("parent line before the fork")
+      2.times.map { |n| fork { logger.info("child line " + n.to_s) } }.each { |pid| Process.wait(pid) }
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(ingest.messages).to contain_exactly("parent line before the fork", "child line 0", "child line 1")
+  end
+
+  it "delivers the lines a forked child logs" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", flush_interval: 60, #{ingest.device_options}))
+      Process.wait(fork { 3.times { |n| logger.info("child line " + n.to_s) } })
+      logger.info("parent line after the fork")
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(ingest.messages).to contain_exactly("child line 0", "child line 1", "child line 2", "parent line after the fork")
+  end
+
+  it "lets a child that hasn't logged exit right away, without waiting on the parent's lines" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", flush_interval: 60, #{ingest.device_options}))
+      logger.info("parent line before the fork")
+      forking = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      Process.wait(fork {})
+      puts Process.clock_gettime(Process::CLOCK_MONOTONIC) - forking
+    RUBY
+
+    expect(result.stdout.to_f).to be < 5
+    expect(ingest.messages).to eq(["parent line before the fork"])
+  end
+
+  it "batches a child's lines as usual when the parent closed the device before forking" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", flush_interval: 60, #{ingest.device_options}))
+      logger.info("parent line")
+      logger.close
+      Process.wait(fork { 3.times { |n| logger.info("child line " + n.to_s) } })
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(ingest.messages).to contain_exactly("parent line", "child line 0", "child line 1", "child line 2")
+    # Lines written after close are each delivered on their own, see Logtail::LogDevices::HTTP#write
+    expect(ingest.batch_sizes).to eq([1, 3])
+  end
+
+  it "delivers a child's lines when it calls flush before leaving with exit!, which skips at_exit hooks" do
+    result = run_ruby(<<-RUBY)
+      require "logtail"
+      logger = Logtail::Logger.new(Logtail::LogDevices::HTTP.new("token", flush_interval: 60, #{ingest.device_options}))
+      logger.info("parent line")
+      Process.wait(fork do
+        begin
+          logger.info("child line")
+          logger.flush
+        ensure
+          exit!(0) # the way Resque ends a job's process
+        end
+      end)
+    RUBY
+
+    expect(result.status).to be_success, result.stderr
+    expect(ingest.messages).to contain_exactly("parent line", "child line")
+  end
+end