cronwatch 0.3.1 → 0.4.0

data/lib/cronwatch/run_handle.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Cronwatch
+  # A run recorded by JobHandle#start or found by JobHandle#resume, to finish
+  # later, perhaps in another process. Lines and metrics wait in the handle
+  # until #flush or #finish. Store failures go to on_error; none of these
+  # methods raises for them.
+  #
+  #   run = SYNC.start(id: event_id)
+  #   # later, perhaps elsewhere
+  #   run = SYNC.resume(event_id)
+  #   run.log("sent 40 emails")
+  #   run.finish                  # or run.fail(error)
+  class RunHandle
+    # Raised by the client's side of finish when the store failed part way
+    # and nothing was recorded (already reported): the handle stays active.
+    #
+    # @api private
+    class Retry < StandardError; end
+
+    # `started_at` is nil when a resumed run could not be read.
+    attr_reader :id, :job, :started_at
+
+    # Made by the client (Client#run_handle), not by apps. `finish` and
+    # `flush` are the client's side of each; `inactive` says why finish has
+    # nothing to do, or is nil.
+    #
+    # @api private
+    def initialize(id:, job:, started_at:, inactive:, finish:, flush:, ignored:)
+      @id = id
+      @job = job
+      @started_at = started_at
+      @inactive = inactive
+      @finish = finish
+      @flush = flush
+      @ignored = ignored
+      # @state guards the flags and which recorder is current; @turn keeps
+      # flush and finish in order, one at a time.
+      @state = Mutex.new
+      @turn = Mutex.new
+      @recorder = fresh_recorder
+      @finished = !inactive.nil?
+      @finish_called = false
+      # The first Output::CAP characters of every line flushed from this
+      # handle, unredacted, or nil before the first flush. The stored output
+      # keeps only the tail, so without it an expect rule at finish would
+      # miss a line logged early, which run would have seen.
+      @head = nil
+    end
+
+    # False once finished, and from the start for a resumed run that already
+    # finished or does not exist.
+    def active?
+      @state.synchronize { !@finished }
+    end
+
+    # Add a line of output, as JobContext#log does. Kept in the handle until flush or finish.
+    def log(*parts)
+      @state.synchronize { @recorder.context.log(*parts) }
+    end
+
+    # Report a number for this run. A later value for the same name replaces an earlier one.
+    def metric(name, value)
+      @state.synchronize { @recorder.context.metric(name, value) }
+    end
+
+    def metrics(values = nil, **more)
+      @state.synchronize { @recorder.context.metrics(values, **more) }
+    end
+
+    # Append the lines and metrics added so far to the stored run, which must
+    # still be running and belong to this job. Output is redacted as it is
+    # written. A read, change and write of the run's row, written only while
+    # it is still running: two processes appending to one run at the same
+    # moment can lose one's lines, but a flush never undoes a finish. When
+    # the write fails the lines stay here for finish. The first 16 KB of
+    # everything flushed stay in the handle, so an expect rule at finish
+    # sees an early line as run would.
+    def flush
+      @turn.synchronize do
+        next if @flush.nil? || @state.synchronize { @finished }
+
+        # Lines logged while this waits on the store go to a new recorder.
+        taken = @state.synchronize do
+          current = @recorder
+          @recorder = fresh_recorder
+          current
+        end
+        lines = taken.output
+        values = taken.metrics
+        next if lines.nil? && values.empty?
+
+        if @flush.call(lines, values)
+          keep_head(taken.expect_text)
+        else
+          put_back(taken)
+        end
+      end
+      nil
+    end
+
+    # Finish the run, judge it like any other and send what that produces.
+    #
+    #   finish                        # ok
+    #   finish(status: "ok")          # ok
+    #   finish(error: e)              # failed, recorded like an error run caught
+    #   finish("text")                # like run's return value: the output when
+    #   finish(result: "text")        # nothing was logged, checked by expect
+    #
+    # Returns the run as recorded, or nil when nothing was: the run was
+    # already finished (here or elsewhere), was not found, or belongs to
+    # another job, which is reported to on_error. When several processes
+    # finish one run, only the one whose write lands judges it. A store that
+    # fails is reported, nothing is recorded, and the handle stays active so
+    # finish can be called again.
+    def finish(outcome = nil)
+      was_inactive = nil
+      again = @state.synchronize do
+        next true if @finish_called
+
+        @finish_called = true
+        was_inactive = @finished
+        @finished = true
+        false
+      end
+      if again
+        @ignored.call("was already finished by this handle")
+        return nil
+      end
+
+      @turn.synchronize do
+        if was_inactive
+          @ignored.call(@inactive)
+          next nil
+        end
+
+        begin
+          @finish.call(@state.synchronize { @recorder }, outcome, @head)
+        rescue Retry
+          reopen
+          nil
+        rescue Exception # rubocop:disable Lint/RescueException
+          # An Interrupt or Timeout mid-finish: the run may still be running,
+          # so the handle stays open (lines kept) for finish to be called again.
+          reopen
+          raise
+        end
+      end
+    end
+
+    # finish(error: error).
+    def fail(error)
+      finish({ error: error })
+    end
+
+    # [failed, result, error] from what finish was given. A Hash with an
+    # :error key is a failure; a String, or a Hash's :result, is the result.
+    #
+    # @api private
+    def self.read_outcome(outcome)
+      case outcome
+      when String then [false, outcome, nil]
+      when Hash
+        key = [:error, "error"].find { |k| outcome.key?(k) }
+        return [true, nil, outcome[key]] if key
+
+        [false, outcome.key?(:result) ? outcome[:result] : outcome["result"], nil]
+      else [false, nil, nil]
+      end
+    end
+
+    private
+
+    def fresh_recorder
+      RunRecorder.new(Run.new(id: @id, job: @job, started_at: @started_at || 0), nil)
+    end
+
+    # A flush that could not write: its lines go back ahead of any logged since.
+    def put_back(taken)
+      @state.synchronize do
+        later = @recorder
+        @recorder = fresh_recorder
+        [taken.expect_text, later.expect_text].each { |text| @recorder.log(text) unless text.nil? }
+        taken.metrics.merge(later.metrics).each { |name, value| @recorder.metric(name, value) }
+      end
+    end
+
+    # A finish that recorded nothing leaves the handle active, to be finished again.
+    def reopen
+      @state.synchronize do
+        @finish_called = false
+        @finished = false
+      end
+    end
+
+    # Keeps the start of what a flush wrote, up to the cap, for expect at finish.
+    def keep_head(text)
+      return if text.nil? || (!@head.nil? && JS.length16(@head) >= Output::CAP)
+
+      @head = JS.head16(@head.nil? || @head.empty? ? text : "#{@head}\n#{text}", Output::CAP)
+    end
+  end
+end

data/lib/cronwatch/stores/active_record.rb

@@ -216,6 +216,18 @@ module Cronwatch
         nil
       end
 
+      # update_run, only while the stored status is one of `from_statuses`,
+      # in one statement (sql.ts updateRunIfSql). Returns whether it wrote.
+      def update_run_if(run, from_statuses)
+        statuses = Array(from_statuses).map(&:to_s)
+        return false if statuses.empty?
+
+        binds = [run.status.to_s, run.finished_at, run.duration_ms, run.error, run.output,
+                 JS.json(run.metrics || {}), run.id, *statuses]
+        changed = with_connection { |conn| conn.exec_update(update_run_if_sql(conn, statuses.length), NAME, binds) }
+        changed.to_i.positive?
+      end
+
       def get_run(id)
         row = read(:get_run, [id]).first
         row && row_to_run(row)
@@ -313,6 +325,17 @@ module Cronwatch
         (@statements[dialect] ||= statements(dialect)).fetch(key)
       end
 
+      # sql.ts `updateRunIfSql`: update_run's statement, only while the
+      # stored status is one of `count` statuses, bound value by value.
+      def update_run_if_sql(conn, count)
+        text = "UPDATE #{@prefix}runs SET status = ?, finished_at = ?, duration_ms = ?, error = ?, output = ?, metrics = ? " \
+               "WHERE id = ? AND status IN (#{Array.new(count, "?").join(", ")})"
+        return text unless self.class.dialect(conn) == :postgres
+
+        n = 0
+        text.gsub("?") { "$#{n += 1}" }
+      end
+
       # sql.ts `statements`: the same text, with `?` numbered for Postgres.
       def statements(dialect)
         p = @prefix

data/lib/cronwatch/stores/memory.rb

@@ -7,7 +7,8 @@ module Cronwatch
     # so a missed run cannot be noticed across one.
     #
     # Every store answers the same methods: init (optional), upsert_job,
-    # get_job, list_jobs, delete_job, insert_run, update_run, get_run,
+    # get_job, list_jobs, delete_job, insert_run, update_run, update_run_if
+    # (optional: without it the client reads the run, then writes it), get_run,
     # list_runs, last_run, running_runs, get_state, set_state, compare_and_set_state
     # (optional: without it the client falls back to set_state), prune and close
     # (optional). They take and return the types in types.rb.
@@ -56,8 +57,11 @@ module Cronwatch
         nil
       end
 
+      # Like SQL's primary key: an id already recorded is refused, never overwritten.
       def insert_run(run)
         sync do
+          raise "run #{run.id} already exists" if @runs.key?(run.id)
+
           @runs[run.id] = clone(run, Run)
           @order[run.id] = (@seq += 1)
         end
@@ -70,19 +74,25 @@ module Cronwatch
           existing = @runs[run.id]
           next unless existing
 
-          copy = clone(run, Run)
-          @runs[run.id] = existing.dup.tap do |r|
-            r.status = copy.status
-            r.finished_at = copy.finished_at
-            r.duration_ms = copy.duration_ms
-            r.error = copy.error
-            r.output = copy.output
-            r.metrics = copy.metrics
-          end
+          @runs[run.id] = finished_fields(existing, run)
         end
         nil
       end
 
+      # update_run, only while the stored run's status is one of
+      # `from_statuses`, in one step. Returns whether it wrote. What lets
+      # exactly one of several processes finishing a run evaluate it.
+      def update_run_if(run, from_statuses)
+        statuses = Array(from_statuses).map(&:to_sym)
+        sync do
+          existing = @runs[run.id]
+          next false unless existing && statuses.include?(existing.status)
+
+          @runs[run.id] = finished_fields(existing, run)
+          true
+        end
+      end
+
       def get_run(id)
         sync { (run = @runs[id]) && clone(run, Run) }
       end
@@ -149,6 +159,19 @@ module Cronwatch
 
       private
 
+      # `existing` with the fields an update writes taken from `run`.
+      def finished_fields(existing, run)
+        copy = clone(run, Run)
+        existing.dup.tap do |r|
+          r.status = copy.status
+          r.finished_at = copy.finished_at
+          r.duration_ms = copy.duration_ms
+          r.error = copy.error
+          r.output = copy.output
+          r.metrics = copy.metrics
+        end
+      end
+
       def sync(&block)
         @lock.synchronize(&block)
       end

data/lib/cronwatch/types.rb

@@ -226,6 +226,7 @@ module Cronwatch
       run = Naming.fetch(hash, "run")
       details = Naming.from_json_value(Naming.fetch(hash, "details") || {})
       details[:after] = details[:after].map(&:to_sym) if details[:after].is_a?(Array)
+      details[:reason] = details[:reason].to_sym if details[:reason].is_a?(String)
       alert = new(
         type: Naming.fetch(hash, "type")&.to_sym,
         run: run && Run.from_h(run),

data/lib/cronwatch/version.rb

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

data/lib/cronwatch/web/app.rb

@@ -3,6 +3,7 @@
 require "base64"
 require "digest"
 require "securerandom"
+require "uri"
 
 module Cronwatch
   # The dashboard and the small JSON API, as a Rack app: the SDK's routes
@@ -26,6 +27,20 @@ module Cronwatch
   #            client's cron_secret as a bearer, for a platform cron.
   # base_path: where the app is mounted, so links resolve. Defaults to the
   #            mount point (SCRIPT_NAME), which is right under Rails' `mount`.
+  # origin:    the public origin the dashboard is served from, such as
+  #            "https://app.example.com". By default the request's own origin
+  #            is used, as Rack reads it (Rack::Request#base_url, which follows
+  #            X-Forwarded-Proto and X-Forwarded-Host the way Rails does). Set
+  #            this to pin it, for an app behind a proxy that does not set
+  #            those headers or one that should not trust them. Used in place
+  #            of the request's origin for the cross-site check on writes, the
+  #            sign-in cookie's Secure flag, the Referer the redirect back after
+  #            a form follows, and the development sign-in line. Read as
+  #            `new URL(value).origin` reads it (Web::Origin) and normalised to
+  #            scheme://host[:port]; anything that is not an absolute http or
+  #            https URL, or has a port outside 1 to 65535, raises
+  #            ArgumentError here. "" counts as unset. Behind more than one
+  #            proxy set it: Rack takes the last of several forwarded values.
   class Web
     # Tells "token not given" (read CRONWATCH_TOKEN) from "token: nil" (open on purpose).
     UNSET = Object.new.freeze
@@ -46,8 +61,9 @@ module Cronwatch
     DECIMAL = /\A[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?\z/
     RADIX = { "x" => 16, "o" => 8, "b" => 2 }.freeze
 
-    def initialize(client = nil, token: UNSET, base_path: nil)
+    def initialize(client = nil, token: UNSET, base_path: nil, origin: nil)
       @client = client
+      @origin = Web.configured_origin(origin)
       @opted_out = token.nil?
       given = token.equal?(UNSET) ? nil : token
       @token = @opted_out ? nil : [given, ENV.fetch("CRONWATCH_TOKEN", nil)].map(&:to_s).find { |t| !t.empty? }
@@ -77,6 +93,14 @@ module Cronwatch
         "Sign in: #{origin}#{base}/?token=#{token}"
     end
 
+    # The `origin` option, normalised to scheme://host[:port], or nil when
+    # unset. Raises on a value that is not an http or https origin, so a typo
+    # fails at startup.
+    # Read as the SDK's `new URL(value).origin` reads it (Web::Origin).
+    def self.configured_origin(value)
+      Origin.parse(value)
+    end
+
     # The client given, or Cronwatch.client when none was.
     def client
       @client || Cronwatch.client
@@ -142,7 +166,7 @@ module Cronwatch
         end
         unless query.nil?
           # Move the token from the URL into a cookie so it is not in history or logs.
-          secure = request.https? ? "; Secure" : ""
+          secure = public_origin(request).start_with?("https:") ? "; Secure" : ""
           return redirect(request.pathname + request.search_without("token"),
                           "set-cookie" => "#{COOKIE}=#{cookie_value(@token)}; Path=#{base.empty? ? "/" : base}; HttpOnly; SameSite=Lax; Max-Age=#{COOKIE_MAX_AGE}#{secure}")
         end
@@ -255,7 +279,7 @@ module Cronwatch
       end
       return unless first
 
-      $stdout.puts(Web.development_sign_in_line(request.origin, base, @token))
+      $stdout.puts(Web.development_sign_in_line(public_origin(request), base, @token))
       $stdout.flush
     end
 
@@ -295,7 +319,7 @@ module Cronwatch
     # a page cannot forge either. Non-browser clients send neither.
     def cross_site?(request)
       origin = request.header("origin")
-      return true if !origin.nil? && origin != request.origin
+      return true if !origin.nil? && origin != public_origin(request)
 
       site = request.header("sec-fetch-site")
       !site.nil? && site != "same-origin" && site != "none"
@@ -378,7 +402,12 @@ module Cronwatch
 
     def redirect_back(request, base)
       referer = request.header("referer") || ""
-      redirect(referer.start_with?("#{request.origin}/") ? referer : "#{base}/")
+      redirect(referer.start_with?("#{public_origin(request)}/") ? referer : "#{base}/")
+    end
+
+    # The origin a browser sees: the `origin` option when set, otherwise the request's own.
+    def public_origin(request)
+      @origin || request.origin
     end
 
     def api(body, status = 200, headers = {})
@@ -426,13 +455,11 @@ module Cronwatch
         @env[key]
       end
 
-      # scheme://host[:port], the page's origin.
+      # scheme://host[:port], the page's origin, lowercased as a browser
+      # writes it in Origin and Referer (Rack's base_url keeps the case of
+      # the Host or X-Forwarded-Host it read).
       def origin
-        @rack.base_url
-      end
-
-      def https?
-        @rack.scheme == "https"
+        @rack.base_url.downcase
       end
 
       # URLSearchParams#get: the first value, or nil.

data/lib/cronwatch/web/origin.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module Cronwatch
+  class Web
+    # Reads the `origin` option as the SDK's `new URL(value).origin` does:
+    # whitespace around it and tabs or line breaks in it are dropped, slashes
+    # after the scheme may be missing or backslashes, credentials are
+    # ignored, the host is lowercased (percent escapes decoded, IPv4 numbers
+    # written out, IPv6 compressed, a non-ASCII host converted to punycode)
+    # and a default port is left out. A port outside 1 to 65535 is refused.
+    module Origin
+      ABSOLUTE = "routes: origin must be an absolute URL such as \"https://app.example.com\", got %s"
+      FORBIDDEN_HOST = /[\x00-\x20#%\/:<>?@\[\\\]^|\x7F]/
+      DEFAULT_PORTS = { "http" => 80, "https" => 443 }.freeze
+
+      module_function
+
+      # scheme://host[:port], or nil for nil or "". Raises ArgumentError otherwise.
+      def parse(value)
+        return nil if value.nil? || value == ""
+        raise ArgumentError, format(ABSOLUTE, JS.json(value)) unless value.is_a?(String)
+
+        text = value.sub(/\A[\x00-\x20]+/, "").sub(/[\x00-\x20]+\z/, "").delete("\t\n\r")
+        match = text.match(/\A([A-Za-z][A-Za-z0-9+.\-]*):(.*)\z/m)
+        raise ArgumentError, format(ABSOLUTE, JS.json(value)) unless match
+
+        scheme = match[1].downcase
+        unless DEFAULT_PORTS.key?(scheme)
+          raise ArgumentError, "routes: origin must be http or https, got #{JS.json(value)}"
+        end
+
+        authority = match[2].sub(%r{\A[/\\]*}, "")[%r{\A[^/\\?#]*}]
+        authority = authority.split("@", -1).last.to_s
+        host, port = split_port(authority, value)
+        host = read_host(host, value)
+        port = port.nil? || port == DEFAULT_PORTS[scheme] ? "" : ":#{port}"
+        "#{scheme}://#{host}#{port}"
+      end
+
+      # [host, port] with the scheme's default port when none is given.
+      def split_port(authority, value)
+        if authority.start_with?("[")
+          close = authority.index("]") or raise ArgumentError, format(ABSOLUTE, JS.json(value))
+          host = authority[0..close]
+          rest = authority[(close + 1)..]
+        else
+          host, colon, rest = authority.rpartition(":")
+          host, rest = rest, "" if colon.empty?
+          rest = ":#{rest}" unless colon.empty?
+        end
+        return [host, nil] if rest.empty? || rest == ":"
+        raise ArgumentError, format(ABSOLUTE, JS.json(value)) unless rest.match?(/\A:[0-9]+\z/)
+
+        port = rest[1..].to_i
+        unless port.between?(1, 65_535)
+          raise ArgumentError, "routes: origin has a port outside 1 to 65535, got #{JS.json(value)}"
+        end
+
+        [host, port]
+      end
+
+      def read_host(host, value)
+        invalid = -> { raise ArgumentError, format(ABSOLUTE, JS.json(value)) }
+        invalid.call if host.empty?
+        if host.start_with?("[")
+          invalid.call unless host.end_with?("]")
+          address = begin
+            IPAddr.new(host[1..-2])
+          rescue IPAddr::Error
+            invalid.call
+          end
+          invalid.call unless address.ipv6?
+          return "[#{address}]"
+        end
+
+        decoded = host.b.gsub(/%([0-9A-Fa-f]{2})/) { Regexp.last_match(1).hex.chr }.force_encoding(Encoding::UTF_8)
+        invalid.call unless decoded.valid_encoding?
+        decoded = to_ascii(decoded, value) unless decoded.ascii_only?
+        decoded = decoded.downcase
+        invalid.call if decoded.empty? || decoded.match?(FORBIDDEN_HOST)
+        ipv4 = ipv4(decoded, invalid)
+        ipv4 || decoded
+      end
+
+      # WHATWG's IPv4 parser, for a host whose last label is a number:
+      # "127.1" and "0x7f.1" are 127.0.0.1. nil for a host that is a name.
+      def ipv4(host, invalid)
+        parts = host.split(".", -1)
+        parts.pop if parts.length > 1 && parts.last.empty?
+        return nil unless number?(parts.last)
+
+        invalid.call if parts.length > 4
+        numbers = parts.map { |part| number(part) || invalid.call }
+        last = numbers.pop
+        invalid.call if numbers.any? { |n| n > 255 } || last >= 256**(4 - numbers.length)
+        address = numbers.each_with_index.sum { |n, i| n * (256**(3 - i)) } + last
+        [24, 16, 8, 0].map { |shift| (address >> shift) & 255 }.join(".")
+      end
+
+      def number?(part)
+        part.match?(/\A[0-9]+\z/) || part.match?(/\A0[xX][0-9A-Fa-f]*\z/)
+      end
+
+      def number(part)
+        return nil if part.empty?
+        return (part.length == 2 ? 0 : part[2..].hex) if part.match?(/\A0[xX][0-9A-Fa-f]*\z/)
+        return part.to_i(8) if part.match?(/\A0[0-7]+\z/)
+
+        part.match?(/\A[0-9]+\z/) && !part.match?(/\A0[0-9]+\z/) ? part.to_i : nil
+      end
+
+      # A non-ASCII host in punycode, through URI::IDNA when this Ruby has it,
+      # else the simpleidn gem, else Addressable's (already loaded by many apps).
+      def to_ascii(host, value)
+        normalized = host.unicode_normalize(:nfc).downcase
+        return URI::IDNA.to_ascii(normalized) if defined?(URI::IDNA) && URI::IDNA.respond_to?(:to_ascii)
+
+        begin
+          require "simpleidn" unless defined?(::SimpleIDN)
+        rescue LoadError
+          nil
+        end
+        return ::SimpleIDN.to_ascii(normalized) if defined?(::SimpleIDN)
+        return ::Addressable::IDNA.to_ascii(normalized) if defined?(::Addressable::IDNA)
+
+        raise ArgumentError, "routes: origin has a host that is not ASCII, got #{JS.json(value)}; write it in punycode " \
+                             "(xn--...) or add the simpleidn gem"
+      end
+    end
+  end
+end

data/lib/cronwatch/web.rb

@@ -15,3 +15,4 @@ end
 require "cronwatch" unless defined?(Cronwatch::Client)
 require_relative "web/html"
 require_relative "web/app"
+require_relative "web/origin"

data/lib/cronwatch.rb

@@ -13,6 +13,7 @@ require_relative "cronwatch/evaluate"
 require_relative "cronwatch/format"
 require_relative "cronwatch/serialize"
 require_relative "cronwatch/job"
+require_relative "cronwatch/run_handle"
 require_relative "cronwatch/http"
 require_relative "cronwatch/stores/memory"
 require_relative "cronwatch/alerts/console"
@@ -20,6 +21,21 @@ require_relative "cronwatch/alerts/custom"
 require_relative "cronwatch/alerts/slack"
 require_relative "cronwatch/alerts/discord"
 require_relative "cronwatch/alerts/webhook"
+require_relative "cronwatch/alerts/provider"
+require_relative "cronwatch/alerts/email"
+require_relative "cronwatch/alerts/sigv4"
+require_relative "cronwatch/alerts/resend"
+require_relative "cronwatch/alerts/postmark"
+require_relative "cronwatch/alerts/sendgrid"
+require_relative "cronwatch/alerts/mailgun"
+require_relative "cronwatch/alerts/ses"
+require_relative "cronwatch/alerts/twilio"
+require_relative "cronwatch/alerts/sentry"
+require_relative "cronwatch/alerts/honeybadger"
+require_relative "cronwatch/alerts/datadog"
+require_relative "cronwatch/alerts/rollbar"
+require_relative "cronwatch/alerts/bugsnag"
+require_relative "cronwatch/alerts/newrelic"
 require_relative "cronwatch/client"
 
 # Cron and scheduled-job monitoring that lives inside your app.
@@ -32,7 +48,7 @@ require_relative "cronwatch/client"
 module Cronwatch
   # The options Cronwatch.configure sets. Anything left unset takes the client's default.
   class Configuration
-    OPTIONS = %i[store alerts triage cron_secret retention defaults redact deliver now on_error].freeze
+    OPTIONS = %i[store alerts triage cron_secret retention defaults redact deliver now on_error sources].freeze
 
     attr_accessor(*OPTIONS)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cronwatch
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Jon C. Phillips
@@ -35,10 +35,25 @@ files:
 - lib/cronwatch.rb
 - lib/cronwatch/abort_signal.rb
 - lib/cronwatch/active_record.rb
+- lib/cronwatch/alerts/bugsnag.rb
 - lib/cronwatch/alerts/console.rb
 - lib/cronwatch/alerts/custom.rb
+- lib/cronwatch/alerts/datadog.rb
 - lib/cronwatch/alerts/discord.rb
+- lib/cronwatch/alerts/email.rb
+- lib/cronwatch/alerts/honeybadger.rb
+- lib/cronwatch/alerts/mailgun.rb
+- lib/cronwatch/alerts/newrelic.rb
+- lib/cronwatch/alerts/postmark.rb
+- lib/cronwatch/alerts/provider.rb
+- lib/cronwatch/alerts/resend.rb
+- lib/cronwatch/alerts/rollbar.rb
+- lib/cronwatch/alerts/sendgrid.rb
+- lib/cronwatch/alerts/sentry.rb
+- lib/cronwatch/alerts/ses.rb
+- lib/cronwatch/alerts/sigv4.rb
 - lib/cronwatch/alerts/slack.rb
+- lib/cronwatch/alerts/twilio.rb
 - lib/cronwatch/alerts/webhook.rb
 - lib/cronwatch/client.rb
 - lib/cronwatch/cron_pattern.rb
@@ -52,11 +67,13 @@ files:
 - lib/cronwatch/js.rb
 - lib/cronwatch/monitored.rb
 - lib/cronwatch/output.rb
+- lib/cronwatch/pg_cron.rb
 - lib/cronwatch/rails.rb
 - lib/cronwatch/rails/active_job.rb
 - lib/cronwatch/rails/check_job.rb
 - lib/cronwatch/rails/railtie.rb
 - lib/cronwatch/rails/tasks.rb
+- lib/cronwatch/run_handle.rb
 - lib/cronwatch/schedule.rb
 - lib/cronwatch/scheduler.rb
 - lib/cronwatch/serialize.rb
@@ -72,6 +89,7 @@ files:
 - lib/cronwatch/web.rb
 - lib/cronwatch/web/app.rb
 - lib/cronwatch/web/html.rb
+- lib/cronwatch/web/origin.rb
 - lib/cronwatch/zone.rb
 - lib/generators/cronwatch/install/install_generator.rb
 homepage: https://cronwatch.dev