cronwatch 0.14.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5dd574dbbc8737a8bc69218d0001eee51f48c3a736eb9ef41e1633a32f5f6c2
-  data.tar.gz: a9f090cdd69a8c19b3c60e4ca2682e68eff5f4a88f70476d9a62b379444ac274
+  metadata.gz: d0a9fcfe8eb1b18e8afd7b80e2b41e62569bf606db798252d2305f9f353235ff
+  data.tar.gz: 12626c9fc256348658a3843ac1704b97ef7cd4fde62f289e0c570c174dd29704
 SHA512:
-  metadata.gz: dd9d2b10aefac9b694fd8053781003c364c6113800a34ead88db2ed9fbbde32805b5d4d39a29a571ed528e9d11044164e1d1f1dc6899946c1d43647bf233e7a4
-  data.tar.gz: e00dbf003d44c0c3d280090d06deb00e397edcff50f9cab6bf65f45215f318521701700bf6fd94ec7dd47a835647c6dc18352bb4ffe54ecd9aa205c5723e65d0
+  metadata.gz: 4d9274543edac3d3400762e5863b08a2b9cf8a818b134996e28a292cfe802552e6ecffbc68b18a7a4a9258499e476e7e7982a546b4b204ebc5f146829e14cebc
+  data.tar.gz: ab1c1ef624f8e94f56eb73c2be364ebf9b799e1b7bceef3a69e4398604e72c1eb63252f894aec82bdb4dfc61d9b9803048a02564dd60d807a273cfde62b0b364

data/lib/cronwatch/client.rb

@@ -428,7 +428,7 @@ module Cronwatch
       update_state(run.job) { |before| [Evaluate.hold_run(Evaluate.on_run_start(definition, run, before, now), run.id), nil] }
       return [] if run.status == :running
 
-      finish_run(definition, run, now)
+      finish_run(definition, run, now, pending_only: true)
     end
 
     # Hands an error to on_error, as a source reports what went wrong. See #report.
@@ -919,6 +919,7 @@ module Cronwatch
       end
       return [] if !%i[running timeout].include?(stored.status) || run.status == :running
 
+      tracked = (read_state(run.job).pending_runs || []).include?(run.id)
       late, ignored = claim_finish(run)
       if ignored
         report(RuntimeError.new("run #{run.id} of #{run.job} #{ignored}; ignored"), "recording #{run.job}")
@@ -931,7 +932,7 @@ module Cronwatch
       end
       return [] if late && run.status != :ok
 
-      finish_run(definition, run, now)
+      finish_run(definition, run, now, pending_only: tracked && !late)
     end
 
     # Takes a run stored without judging out of the job's pending runs, so a
@@ -1028,13 +1029,14 @@ module Cronwatch
           return "belongs to job \"#{stored.job}\"" if stored.job != run.job
         end
       end
+      tracked = (read_state(run.job).pending_runs || []).include?(run.id)
       late, ignored = claim_finish(run)
       return ignored if ignored
 
       if !judge
         release_unjudged(run)
       elsif !late || run.status == :ok
-        finish_run(Serialize.to_stored(definition), run, finished_at)
+        finish_run(Serialize.to_stored(definition), run, finished_at, pending_only: tracked && !late)
       end
       nil
     end
@@ -1250,7 +1252,7 @@ module Cronwatch
         end
         next if run.status == :running || !run.finished_at.is_a?(Numeric) || run.finished_at > at - Evaluate::SEND_LEASE_MS
 
-        alerts.concat(finish_run(stored.definition, run, at))
+        alerts.concat(finish_run(stored.definition, run, at, pending_only: true))
       rescue StandardError => e
         report(e, "evaluating run #{id} of #{stored.name}")
       end
@@ -1260,11 +1262,12 @@ module Cronwatch
     # Evaluate a finished run (ok, failed, or timed out by a check), already
     # written, against the job's state and send what that produces. The
     # alerts are written with that state (see outbox). Never raises.
-    def finish_run(definition, run, at)
+    def finish_run(definition, run, at, pending_only: false)
       held = nil
       begin
         past = nil
         _, held = update_state(run.job) do |previous|
+          next [previous, Outbox.new([], 0)] if pending_only && !(previous.pending_runs || []).include?(run.id)
           past ||= history(run)
           before = Evaluate.release_run(previous, run.id)
           outbox(Evaluate.apply_silence(before, Evaluate.on_run_finish(definition, run, before, past, at), at), definition, at)

data/lib/cronwatch/job.rb

@@ -100,7 +100,7 @@ module Cronwatch
   class RunRecorder
     # Lines are dropped from the front once the output is well past the cap;
     # Output.redact_and_cap trims it exactly at the end.
-    KEEP = 64 * 1024
+    KEEP = Output::CAP + Output::REDACT_EDGE + 2
 
     attr_reader :context, :signal
 
@@ -111,7 +111,9 @@ module Cronwatch
       # dropped from @lines: what expect_text needs once the output runs long.
       @head = []
       @head_size = 0
-      @dropped = false
+      @whole = ""
+      @tail = ""
+      @logged = false
       @metrics = {}
       @lock = Mutex.new
       @signal = AbortSignal.new(timeout_ms)
@@ -121,15 +123,26 @@ module Cronwatch
     def log(line)
       length = JS.length16(line)
       @lock.synchronize do
+        separator = @logged ? "\n" : ""
+        @logged = true
+        if @whole
+          @whole = JS.length16(@whole) + separator.length + length <= 2 * Output::CAP ? @whole + separator + line : nil
+        end
+        @tail = JS.tail16(@tail + separator + JS.tail16(line, Output::CAP), Output::CAP).dup
         if @head_size < Output::CAP
-          @head << line
+          @head << JS.head16(line, Output::CAP - @head_size).dup
           @head_size += length + 1
         end
+        line = Output.strip_nul(line)
+        length = JS.length16(line)
+        if length >= KEEP
+          line = JS.tail16(line, KEEP - 1).dup
+          length = JS.length16(line)
+        end
         @lines << line
         @size += length + 1
         while @size > KEEP && @lines.length > 1
           @size -= JS.length16(@lines.shift) + 1
-          @dropped = true
         end
       end
     end
@@ -138,7 +151,7 @@ module Cronwatch
       @lock.synchronize { @metrics[name] = value }
     end
 
-    # The lines still held (past 64 KB the oldest are let go), joined and not
+    # The lines still held (past the bounded redaction window the oldest are let go), joined and not
     # yet capped: the client redacts them first, then caps them
     # (Output.redact_and_cap).
     def output
@@ -152,10 +165,9 @@ module Cronwatch
       @lock.synchronize do
         next nil if @lines.empty?
 
-        all = @lines.join("\n")
-        next all if !@dropped && JS.length16(all) <= 2 * Output::CAP
+        next @whole if @whole
 
-        "#{JS.head16(@head.join("\n"), Output::CAP)}\n#{JS.tail16(all, Output::CAP)}"
+        "#{JS.head16(@head.join("\n"), Output::CAP)}\n#{@tail}"
       end
     end
 

data/lib/cronwatch/version.rb

@@ -2,5 +2,5 @@
 
 module Cronwatch
   # Kept in step with @cronwatch/sdk.
-  VERSION = "0.14.0"
+  VERSION = "0.14.1"
 end

data/lib/cronwatch/web/app.rb

@@ -264,6 +264,7 @@ module Cronwatch
       # the URL and every access log. Cross-site posts were refused above.
       if @token && method == "POST" && path == "/signin"
         body = read_body(request)
+        return html(HTML.message_page("Bad request", "Malformed request body", base), 400) if body.equal?(BAD_BODY)
         # A body too large is no token at all.
         sent = body.equal?(TOO_LARGE) ? nil : body["token"]
         return sign_in_page(base) if sent.nil? || !HTTP.constant_time_equal?(sent, @token)
@@ -341,6 +342,7 @@ module Cronwatch
         if action == "silence"
           body = read_body(request)
           return html(HTML.message_page("Not silenced", "The request was too large.", base), 413) if body.equal?(TOO_LARGE)
+          return html(HTML.message_page("Not silenced", "Malformed request body", base), 400) if body.equal?(BAD_BODY)
 
           begin
             duration = silence_duration(body["for"])
@@ -388,6 +390,7 @@ module Cronwatch
         if rest[2] == "silence"
           body = read_body(request)
           return api({ ok: false, error: "Request body too large" }, 413) if body.equal?(TOO_LARGE)
+          return api({ ok: false, error: "Malformed request body" }, 400) if body.equal?(BAD_BODY)
 
           begin
             duration = silence_duration(body.key?("for") ? body["for"] : request.query("for"))
@@ -530,7 +533,8 @@ module Cronwatch
 
     # A request body past Request::MAX_BODY, which read_body answers with.
     TOO_LARGE = Object.new.freeze
-    private_constant :TOO_LARGE
+    BAD_BODY = Object.new.freeze
+    private_constant :TOO_LARGE, :BAD_BODY
 
     # The form fields or JSON object of a request, each value as String(value)
     # gives it in JavaScript, or TOO_LARGE for a body past Request::MAX_BODY.
@@ -546,13 +550,13 @@ module Cronwatch
       if json
         data = JSON.parse(Output.utf8(request.body).delete_prefix(""))
         return data.to_h { |k, v| [k.to_s, js_string(v)] } if data.is_a?(Hash)
-        return data.each_with_index.to_h { |v, i| [i.to_s, js_string(v)] } if data.is_a?(Array)
+        return BAD_BODY
       else
         return request.form.transform_values { |v| form_value(v) }
       end
       {}
     rescue StandardError
-      {}
+      BAD_BODY
     end
 
     # String(value) for a parsed JSON value.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cronwatch
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Jon C. Phillips