scheduled 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 688c45f27921579d66859e13503929c9de904061
-  data.tar.gz: cc72fa658f792a10ec443ea1dd79f8ef4e069448
+SHA256:
+  metadata.gz: db4f2341051e6e731d151c2c77742da414d297e42ea9bd5935d0621a36936c58
+  data.tar.gz: 1eb6ed8ce17b349fb007b84eeed4b1ab6da028e7fc08fa3af0a4e7e0551970a1
 SHA512:
-  metadata.gz: f254da84808cdaa0d9c1985c52dac01ba120958241d94fcc0c7438d6c6397616b391aa5ec87e70f79242c7643a74c968a49e7e0135fc13081d17c4d3ccf01601
-  data.tar.gz: 61e96fa4874cd744cebd95c21914681511b9567b8b3e8e6d27090655707e83b6e95ab539a266ba2b3ec323d2ee29c7ec7e04064b9daf6a919bc3470a253612f8
+  metadata.gz: 2aeea0f548aeb7b8dc342b0b7d1e861182f32f752e51c9a5ff2448b3d525b09c96a46986cbdfdf35767ee63341499a5a061bb8d3ff704d1aa5918204907ef953
+  data.tar.gz: b67bfea285af8662eeea8901a55e92d39d2a28f3afb5fb6d2f4d97b3a1338ca64dc9e9faef7e2351e7e5c77e22be3eeba7f10aa3916eb629d0bb814212d7c43a

data/lib/scheduled/cron_parser.rb

@@ -25,298 +25,300 @@
 require 'set'
 require 'date'
 
-# Parses cron expressions and computes the next occurence of the "job"
-#
-class CronParser
-  # internal "mutable" time representation
-  class InternalTime
-    attr_accessor :year, :month, :day, :hour, :min
-    attr_accessor :time_source
-
-    def initialize(time,time_source = Time)
-      @year = time.year
-      @month = time.month
-      @day = time.day
-      @hour = time.hour
-      @min = time.min
+module Scheduled
+  # Parses cron expressions and computes the next occurence of the "job"
+  #
+  class CronParser
+    # internal "mutable" time representation
+    class InternalTime
+      attr_accessor :year, :month, :day, :hour, :min
+      attr_accessor :time_source
+
+      def initialize(time,time_source = Time)
+        @year = time.year
+        @month = time.month
+        @day = time.day
+        @hour = time.hour
+        @min = time.min
+
+        @time_source = time_source
+      end
 
-      @time_source = time_source
-    end
+      def to_time
+        time_source.local(@year, @month, @day, @hour, @min, 0)
+      end
 
-    def to_time
-      time_source.local(@year, @month, @day, @hour, @min, 0)
+      def inspect
+        [year, month, day, hour, min].inspect
+      end
     end
 
-    def inspect
-      [year, month, day, hour, min].inspect
+    SYMBOLS = {
+      "jan" => "1",
+      "feb" => "2",
+      "mar" => "3",
+      "apr" => "4",
+      "may" => "5",
+      "jun" => "6",
+      "jul" => "7",
+      "aug" => "8",
+      "sep" => "9",
+      "oct" => "10",
+      "nov" => "11",
+      "dec" => "12",
+
+      "sun" => "0",
+      "mon" => "1",
+      "tue" => "2",
+      "wed" => "3",
+      "thu" => "4",
+      "fri" => "5",
+      "sat" => "6"
+    }
+
+    def initialize(source,time_source = Time)
+      @source = interpret_vixieisms(source)
+      @time_source = time_source
+      validate_source
     end
-  end
-
-  SYMBOLS = {
-     "jan" => "1",
-     "feb" => "2",
-     "mar" => "3",
-     "apr" => "4",
-     "may" => "5",
-     "jun" => "6",
-     "jul" => "7",
-     "aug" => "8",
-     "sep" => "9",
-     "oct" => "10",
-     "nov" => "11",
-     "dec" => "12",
-
-     "sun" => "0",
-     "mon" => "1",
-     "tue" => "2",
-     "wed" => "3",
-     "thu" => "4",
-     "fri" => "5",
-     "sat" => "6"
-  }
-
-  def initialize(source,time_source = Time)
-    @source = interpret_vixieisms(source)
-    @time_source = time_source
-    validate_source
-  end
 
-  def interpret_vixieisms(spec)
-    case spec
-    when '@reboot'
-      raise ArgumentError, "Can't predict last/next run of @reboot"
-    when '@yearly', '@annually'
-      '0 0 1 1 *'
-    when '@monthly'
-      '0 0 1 * *'
-    when '@weekly'
-      '0 0 * * 0'
-    when '@daily', '@midnight'
-      '0 0 * * *'
-    when '@hourly'
-      '0 * * * *'
-    else
-      spec
+    def interpret_vixieisms(spec)
+      case spec
+      when '@reboot'
+        raise ArgumentError, "Can't predict last/next run of @reboot"
+      when '@yearly', '@annually'
+        '0 0 1 1 *'
+      when '@monthly'
+        '0 0 1 * *'
+      when '@weekly'
+        '0 0 * * 0'
+      when '@daily', '@midnight'
+        '0 0 * * *'
+      when '@hourly'
+        '0 * * * *'
+      else
+        spec
+      end
     end
-  end
 
 
-  # returns the next occurence after the given date
-  def next(now = @time_source.now, num = 1)
-    t = InternalTime.new(now, @time_source)
+    # returns the next occurence after the given date
+    def next(now = @time_source.now, num = 1)
+      t = InternalTime.new(now, @time_source)
 
-    unless time_specs[:month][0].include?(t.month)
-      nudge_month(t)
-      t.day = 0
-    end
+      unless time_specs[:month][0].include?(t.month)
+        nudge_month(t)
+        t.day = 0
+      end
 
-    unless interpolate_weekdays(t.year, t.month)[0].include?(t.day)
-      nudge_date(t)
-      t.hour = -1
-    end
+      unless interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+        nudge_date(t)
+        t.hour = -1
+      end
 
-    unless time_specs[:hour][0].include?(t.hour)
-      nudge_hour(t)
-      t.min = -1
-    end
+      unless time_specs[:hour][0].include?(t.hour)
+        nudge_hour(t)
+        t.min = -1
+      end
 
-    # always nudge the minute
-    nudge_minute(t)
-    t = t.to_time
-    if num > 1
-      recursive_calculate(:next,t,num)
-    else
-      t
+      # always nudge the minute
+      nudge_minute(t)
+      t = t.to_time
+      if num > 1
+        recursive_calculate(:next,t,num)
+      else
+        t
+      end
     end
-  end
 
-  # returns the last occurence before the given date
-  def last(now = @time_source.now, num=1)
-    t = InternalTime.new(now,@time_source)
+    # returns the last occurence before the given date
+    def last(now = @time_source.now, num=1)
+      t = InternalTime.new(now,@time_source)
 
-    unless time_specs[:month][0].include?(t.month)
-      nudge_month(t, :last)
-      t.day = 32
-    end
+      unless time_specs[:month][0].include?(t.month)
+        nudge_month(t, :last)
+        t.day = 32
+      end
 
-    if t.day == 32 || !interpolate_weekdays(t.year, t.month)[0].include?(t.day)
-      nudge_date(t, :last)
-      t.hour = 24
-    end
+      if t.day == 32 || !interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+        nudge_date(t, :last)
+        t.hour = 24
+      end
 
-    unless time_specs[:hour][0].include?(t.hour)
-      nudge_hour(t, :last)
-      t.min = 60
-    end
+      unless time_specs[:hour][0].include?(t.hour)
+        nudge_hour(t, :last)
+        t.min = 60
+      end
 
-    # always nudge the minute
-    nudge_minute(t, :last)
-    t = t.to_time
-    if num > 1
-      recursive_calculate(:last,t,num)
-    else
-      t
+      # always nudge the minute
+      nudge_minute(t, :last)
+      t = t.to_time
+      if num > 1
+        recursive_calculate(:last,t,num)
+      else
+        t
+      end
     end
-  end
 
 
-  SUBELEMENT_REGEX = %r{^(\d+)(-(\d+)(/(\d+))?)?$}
-  def parse_element(elem, allowed_range)
-    values = elem.split(',').map do |subel|
-      if subel =~ /^\*/
-        step = subel.length > 1 ? subel[2..-1].to_i : 1
-        stepped_range(allowed_range, step)
-      else
-        if SUBELEMENT_REGEX === subel
-          if $5 # with range
-            stepped_range($1.to_i..$3.to_i, $5.to_i)
-          elsif $3 # range without step
-            stepped_range($1.to_i..$3.to_i, 1)
-          else # just a numeric
-            [$1.to_i]
-          end
+    SUBELEMENT_REGEX = %r{^(\d+)(-(\d+)(/(\d+))?)?$}
+    def parse_element(elem, allowed_range)
+      values = elem.split(',').map do |subel|
+        if subel =~ /^\*/
+          step = subel.length > 1 ? subel[2..-1].to_i : 1
+          stepped_range(allowed_range, step)
         else
-          raise ArgumentError, "Bad Vixie-style specification #{subel}"
+          if SUBELEMENT_REGEX === subel
+            if $5 # with range
+              stepped_range($1.to_i..$3.to_i, $5.to_i)
+            elsif $3 # range without step
+              stepped_range($1.to_i..$3.to_i, 1)
+            else # just a numeric
+              [$1.to_i]
+            end
+          else
+            raise ArgumentError, "Bad Vixie-style specification #{subel}"
+          end
         end
-      end
-    end.flatten.sort
+      end.flatten.sort
 
-    [Set.new(values), values, elem]
-  end
-
-
-  protected
-
-  def recursive_calculate(meth,time,num)
-    array = [time]
-    num.-(1).times do |num|
-      array << self.send(meth, array.last)
+      [Set.new(values), values, elem]
     end
-    array
-  end
 
-  # returns a list of days which do both match time_spec[:dom] or time_spec[:dow]
-  def interpolate_weekdays(year, month)
-    @_interpolate_weekdays_cache ||= {}
-    @_interpolate_weekdays_cache["#{year}-#{month}"] ||= interpolate_weekdays_without_cache(year, month)
-  end
 
-  def interpolate_weekdays_without_cache(year, month)
-    t = Date.new(year, month, 1)
-    valid_mday, _, mday_field = time_specs[:dom]
-    valid_wday, _, wday_field = time_specs[:dow]
+    protected
 
-    # Careful, if both DOW and DOM fields are non-wildcard,
-    # then we only need to match *one* for cron to run the job:
-    if not (mday_field == '*' and wday_field == '*')
-      valid_mday = [] if mday_field == '*'
-      valid_wday = [] if wday_field == '*'
+    def recursive_calculate(meth,time,num)
+      array = [time]
+      num.-(1).times do
+        array << self.send(meth, array.last)
+      end
+      array
     end
-    # Careful: crontabs may use either 0 or 7 for Sunday:
-    valid_wday << 0 if valid_wday.include?(7)
 
-    result = []
-    while t.month == month
-      result << t.mday if valid_mday.include?(t.mday) || valid_wday.include?(t.wday)
-      t = t.succ
+    # returns a list of days which do both match time_spec[:dom] or time_spec[:dow]
+    def interpolate_weekdays(year, month)
+      @_interpolate_weekdays_cache ||= {}
+      @_interpolate_weekdays_cache["#{year}-#{month}"] ||= interpolate_weekdays_without_cache(year, month)
     end
 
-    [Set.new(result), result]
-  end
+    def interpolate_weekdays_without_cache(year, month)
+      t = Date.new(year, month, 1)
+      valid_mday, _, mday_field = time_specs[:dom]
+      valid_wday, _, wday_field = time_specs[:dow]
 
-  def nudge_year(t, dir = :next)
-    t.year = t.year + (dir == :next ? 1 : -1)
-  end
+      # Careful, if both DOW and DOM fields are non-wildcard,
+      # then we only need to match *one* for cron to run the job:
+      if not (mday_field == '*' and wday_field == '*')
+        valid_mday = [] if mday_field == '*'
+        valid_wday = [] if wday_field == '*'
+      end
+      # Careful: crontabs may use either 0 or 7 for Sunday:
+      valid_wday << 0 if valid_wday.include?(7)
 
-  def nudge_month(t, dir = :next)
-    spec = time_specs[:month][1]
-    next_value = find_best_next(t.month, spec, dir)
-    t.month = next_value || (dir == :next ? spec.first : spec.last)
+      result = []
+      while t.month == month
+        result << t.mday if valid_mday.include?(t.mday) || valid_wday.include?(t.wday)
+        t = t.succ
+      end
 
-    nudge_year(t, dir) if next_value.nil?
+      [Set.new(result), result]
+    end
 
-    # we changed the month, so its likely that the date is incorrect now
-    valid_days = interpolate_weekdays(t.year, t.month)[1]
-    t.day = dir == :next ? valid_days.first : valid_days.last
-  end
+    def nudge_year(t, dir = :next)
+      t.year = t.year + (dir == :next ? 1 : -1)
+    end
 
-  def date_valid?(t, dir = :next)
-    interpolate_weekdays(t.year, t.month)[0].include?(t.day)
-  end
+    def nudge_month(t, dir = :next)
+      spec = time_specs[:month][1]
+      next_value = find_best_next(t.month, spec, dir)
+      t.month = next_value || (dir == :next ? spec.first : spec.last)
 
-  def nudge_date(t, dir = :next, can_nudge_month = true)
-    spec = interpolate_weekdays(t.year, t.month)[1]
-    next_value = find_best_next(t.day, spec, dir)
-    t.day = next_value || (dir == :next ? spec.first : spec.last)
+      nudge_year(t, dir) if next_value.nil?
 
-    nudge_month(t, dir) if next_value.nil? && can_nudge_month
-  end
+      # we changed the month, so its likely that the date is incorrect now
+      valid_days = interpolate_weekdays(t.year, t.month)[1]
+      t.day = dir == :next ? valid_days.first : valid_days.last
+    end
 
-  def nudge_hour(t, dir = :next)
-    spec = time_specs[:hour][1]
-    next_value = find_best_next(t.hour, spec, dir)
-    t.hour = next_value || (dir == :next ? spec.first : spec.last)
+    def date_valid?(t, dir = :next)
+      interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+    end
 
-    nudge_date(t, dir) if next_value.nil?
-  end
+    def nudge_date(t, dir = :next, can_nudge_month = true)
+      spec = interpolate_weekdays(t.year, t.month)[1]
+      next_value = find_best_next(t.day, spec, dir)
+      t.day = next_value || (dir == :next ? spec.first : spec.last)
 
-  def nudge_minute(t, dir = :next)
-    spec = time_specs[:minute][1]
-    next_value = find_best_next(t.min, spec, dir)
-    t.min = next_value || (dir == :next ? spec.first : spec.last)
+      nudge_month(t, dir) if next_value.nil? && can_nudge_month
+    end
 
-    nudge_hour(t, dir) if next_value.nil?
-  end
+    def nudge_hour(t, dir = :next)
+      spec = time_specs[:hour][1]
+      next_value = find_best_next(t.hour, spec, dir)
+      t.hour = next_value || (dir == :next ? spec.first : spec.last)
 
-  def time_specs
-    @time_specs ||= begin
-      # tokens now contains the 5 fields
-      tokens = substitute_parse_symbols(@source).split(/\s+/)
-      {
-        :minute => parse_element(tokens[0], 0..59), #minute
-        :hour   => parse_element(tokens[1], 0..23), #hour
-        :dom    => parse_element(tokens[2], 1..31), #DOM
-        :month  => parse_element(tokens[3], 1..12), #mon
-        :dow    => parse_element(tokens[4], 0..6)  #DOW
-      }
+      nudge_date(t, dir) if next_value.nil?
     end
-  end
 
-  def substitute_parse_symbols(str)
-    SYMBOLS.inject(str.downcase) do |s, (symbol, replacement)|
-      s.gsub(symbol, replacement)
+    def nudge_minute(t, dir = :next)
+      spec = time_specs[:minute][1]
+      next_value = find_best_next(t.min, spec, dir)
+      t.min = next_value || (dir == :next ? spec.first : spec.last)
+
+      nudge_hour(t, dir) if next_value.nil?
     end
-  end
 
+    def time_specs
+      @time_specs ||= begin
+        # tokens now contains the 5 fields
+        tokens = substitute_parse_symbols(@source).split(/\s+/)
+        {
+          :minute => parse_element(tokens[0], 0..59), #minute
+          :hour   => parse_element(tokens[1], 0..23), #hour
+          :dom    => parse_element(tokens[2], 1..31), #DOM
+          :month  => parse_element(tokens[3], 1..12), #mon
+          :dow    => parse_element(tokens[4], 0..6)  #DOW
+        }
+      end
+    end
 
-  def stepped_range(rng, step = 1)
-    len = rng.last - rng.first
+    def substitute_parse_symbols(str)
+      SYMBOLS.inject(str.downcase) do |s, (symbol, replacement)|
+        s.gsub(symbol, replacement)
+      end
+    end
 
-    num = len.div(step)
-    result = (0..num).map { |i| rng.first + step * i }
 
-    result.pop if result[-1] == rng.last and rng.exclude_end?
-    result
-  end
+    def stepped_range(rng, step = 1)
+      len = rng.last - rng.first
 
+      num = len.div(step)
+      result = (0..num).map { |i| rng.first + step * i }
 
-  # returns the smallest element from allowed which is greater than current
-  # returns nil if no matching value was found
-  def find_best_next(current, allowed, dir)
-    if dir == :next
-      allowed.sort.find { |val| val > current }
-    else
-      allowed.sort.reverse.find { |val| val < current }
+      result.pop if result[-1] == rng.last and rng.exclude_end?
+      result
     end
-  end
 
-  def validate_source
-    unless @source.respond_to?(:split)
-      raise ArgumentError, 'not a valid cronline'
+
+    # returns the smallest element from allowed which is greater than current
+    # returns nil if no matching value was found
+    def find_best_next(current, allowed, dir)
+      if dir == :next
+        allowed.sort.find { |val| val > current }
+      else
+        allowed.sort.reverse.find { |val| val < current }
+      end
     end
-    source_length = @source.split(/\s+/).length
-    unless source_length >= 5 && source_length <= 6
-      raise ArgumentError, 'not a valid cronline'
+
+    def validate_source
+      unless @source.respond_to?(:split)
+        raise ArgumentError, 'not a valid cronline'
+      end
+      source_length = @source.split(/\s+/).length
+      unless source_length >= 5 && source_length <= 6
+        raise ArgumentError, 'not a valid cronline'
+      end
     end
   end
 end

data/lib/scheduled/instrumenters.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Scheduled
+  module Instrumenters
+    ##
+    # An Instrumentor that performs work without measurement
+    class Noop
+      def self.instrument(name, payload = {})
+        yield payload if block_given?
+      end
+    end
+  end
+end

data/lib/scheduled/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Scheduled
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/scheduled.rb

@@ -1,60 +1,180 @@
 # frozen_string_literal: true
+
+require "logger"
 require "concurrent"
 require "scheduled/cron_parser"
+require "scheduled/instrumenters"
 
+##
+# Schedule jobs to run at specific intervals.
+#
 module Scheduled
+  # @api private
   Job = Struct.new(:last_run)
 
-  module_function
+  # Context the job is run in
+  # @api private
+  Context = Struct.new(:logger)
 
-  def every(interval, &block)
-    if interval.is_a?(Integer)
-      task = Concurrent::TimerTask.new(execution_interval: interval, run_now: true) do
-        block.call
-      end
+  # Default task logger implementation
+  DEFAULT_TASK_LOGGER = ->(logger, name) {
+    logger = logger.dup
+    logger.progname = name if logger.respond_to?(:progname=)
+    logger
+  }
+  private_constant :DEFAULT_TASK_LOGGER
+
+  @task_logger = DEFAULT_TASK_LOGGER
+  @logger = Logger.new($stdout, level: :info)
+  @instrumenter = Instrumenters::Noop
+
+  class << self
+    # An object that when called creates a logger for the provided task
+    #
+    # @return [#call(original_logger, task_name)]
+    #   a callable object that returns a a +Logger+ like instance which responds to +info+ and +debug+
+    # @example
+    #   Scheduled.task_logger = ->(original_logger, task_name) {
+    #     logger = original_logger.dup
+    #     logger.progname = task_name
+    #     logger
+    #   }
+    attr_accessor :task_logger
+
+    # @return [#info, #debug]
+    #   a +Logger+ like instance which responds to +info+ and +debug+
+    attr_accessor :logger
+
+    # @return [#instrument]
+    #   an +ActiveSupport::Notifications+ like object which responds to +instrument+
+    attr_accessor :instrumenter
+
+    # An object that responds to +call+ and receives an exception as an argument.
+    attr_accessor :error_notifier
 
-      task.execute
+    # Create task to run every interval.
+    #
+    # @param interval [Integer, String, #call]
+    #   Interval to perform task.
+    #
+    #   When provided as an +Integer+, is the number of seconds between task runs.
+    #
+    #   When provided as a +String+, is a cron-formatted interval line.
+    #
+    #   When provided as an object that responds to +#call+, will run when truthy.
+    #
+    # @param name [String, false]
+    #   Name of task, used during logging. Will use block location and line number by
+    #   default. Use +false+ to prevent a name being automatically assigned.
+    #
+    # @return [void]
+    #
+    # @example Run every 60 seconds
+    #   Scheduled.every(60) { puts "Running every 60 seconds" }
+    #
+    # @example Run every day at 9:10 AM
+    #   Scheduled.every("10 9 * * *") { puts "Performing billing" }
+    #
+    def every(interval, name: nil, &block)
+      name ||= block_name(block)
+      logger = logger_for_task(name, block)
+      context = Context.new(logger)
 
-    elsif interval.is_a?(String)
-      run = ->() {
-        parsed_cron = CronParser.new(interval)
-        next_tick_delay = parsed_cron.next(Time.now) - Time.now
+      rescued_block = ->() do
+        instrumenter.instrument("scheduled.run", {name: name}) do |payload|
+          begin
+            result = context.instance_eval(&block)
+            payload[:result] = result
+            result
+          rescue => e
+            payload[:exception] = [e.class.to_s, e.message]
+            payload[:exception_object] = e
 
-        task = Concurrent::ScheduledTask.execute(next_tick_delay) do
-          block.call
-          run.call
+            if error_notifier
+              error_notifier.call(e)
+            end
+          end
+        end
+      end
+
+      if interval.is_a?(Integer)
+        logger.debug { "Running every #{interval} seconds" }
+
+        task = Concurrent::TimerTask.new(execution_interval: interval, run_now: true) do
+          rescued_block.call
         end
 
         task.execute
-      }
 
-      run.call
+      elsif interval.is_a?(String)
+        run = ->() {
+          now = Time.now
+          parsed_cron = CronParser.new(interval)
+          next_tick_delay = [1, (parsed_cron.next(now) - now).ceil].max
+
+          logger.debug { "Next run at #{now + next_tick_delay} (tick delay of #{next_tick_delay})" }
+
+          task = Concurrent::ScheduledTask.execute(next_tick_delay) do
+            rescued_block.call
+            run.call
+          end
 
-    elsif interval.respond_to?(:call)
-      job = Job.new
+          task.execute
+        }
 
-      task = Concurrent::TimerTask.new(execution_interval: 1, run_now: true) do |timer_task|
-        case interval.call(job)
-        when true
-          block.call
+        run.call
 
-          job.last_run = Time.now
-        when :cancel
-          timer_task.shutdown
+      elsif interval.respond_to?(:call)
+        job = Job.new
+
+        task = Concurrent::TimerTask.new(execution_interval: 1, run_now: true) do |timer_task|
+          case interval.call(job)
+          when true
+            rescued_block.call
+
+            job.last_run = Time.now
+          when :cancel
+            logger.debug { "Received :cancel. Shutting down." }
+            timer_task.shutdown
+          end
         end
+
+        task.execute
+      else
+        raise ArgumentError, "Unsupported value for interval"
       end
+    end
+
+    # Run task scheduler indefinitely.
+    #
+    # @return [void]
+    def wait
+      trap("INT") { exit }
 
-      task.execute
-    else
-      raise ArgumentError, "Unsupported value for interval"
+      loop do
+        sleep 1
+      end
     end
-  end
 
-  def wait
-    trap("INT") { exit }
+    private
+
+    # Build a logger for the current task
+    # @api private
+    def logger_for_task(name, block)
+      return logger if name == false
 
-    loop do
-      sleep 1
+      task_logger.call(logger, name)
     end
+
+    # Generate name for block
+    # @api private
+    def block_name(block)
+      file, line = block.source_location
+      "#{file}:#{line}"
+    end 
+  end
+
+  Scheduled.error_notifier = proc do |error|
+    $stderr.puts error.full_message
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scheduled
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Adam Daniels
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-06-20 00:00:00.000000000 Z
+date: 2023-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -24,21 +24,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rubygems-tasks
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-description: 
+description:
 email: adam@mediadrive.ca
 executables: []
 extensions: []
@@ -47,12 +33,13 @@ files:
 - README.md
 - lib/scheduled.rb
 - lib/scheduled/cron_parser.rb
+- lib/scheduled/instrumenters.rb
 - lib/scheduled/version.rb
 homepage: https://github.com/adam12/scheduled
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -67,9 +54,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: A very lightweight clock process with minimal dependencies and no magic.
 test_files: []