celluloid 0.16.0 → 0.17.0

data/lib/celluloid/legacy.rb

@@ -1,9 +0,0 @@
-class Thread
-  def self.mailbox
-    Celluloid.mailbox
-  end
-
-  def self.receive(timeout = nil, &block)
-    Celluloid.receive(timeout, &block)
-  end
-end

data/lib/celluloid/links.rb

@@ -1,36 +0,0 @@
-module Celluloid
-  # Linked actors send each other system events
-  class Links
-    include Enumerable
-
-    def initialize
-      @links = {}
-    end
-
-    # Add an actor to the current links
-    def <<(actor)
-      @links[actor.mailbox.address] = actor
-    end
-
-    # Do links include the given actor?
-    def include?(actor)
-      @links.has_key? actor.mailbox.address
-    end
-
-    # Remove an actor from the links
-    def delete(actor)
-      @links.delete actor.mailbox.address
-    end
-
-    # Iterate through all links
-    def each
-      @links.each { |_, actor| yield(actor) }
-    end
-
-    # Generate a string representation
-    def inspect
-      links = self.map(&:inspect).join(',')
-      "#<#{self.class}[#{links}]>"
-    end
-  end
-end

data/lib/celluloid/logger.rb

@@ -1,93 +0,0 @@
-module Celluloid
-  module Logger
-    class WithBacktrace
-      def initialize(backtrace)
-        @backtrace = backtrace
-      end
-
-      def debug(string)
-        Celluloid.logger.debug(decorate(string))
-      end
-
-      def info(string)
-        Celluloid.logger.info(decorate(string))
-      end
-
-      def warn(string)
-        Celluloid.logger.warn(decorate(string))
-      end
-
-      def error(string)
-        Celluloid.logger.error(decorate(string))
-      end
-
-      def decorate(string)
-        [string, @backtrace].join("\n\t")
-      end
-    end
-
-    @exception_handlers = []
-    module_function
-
-    def with_backtrace(backtrace)
-      yield WithBacktrace.new(backtrace) if Celluloid.logger
-    end
-
-    # Send a debug message
-    def debug(string)
-      Celluloid.logger.debug(string) if Celluloid.logger
-    end
-
-    # Send a info message
-    def info(string)
-      Celluloid.logger.info(string) if Celluloid.logger
-    end
-
-    # Send a warning message
-    def warn(string)
-      Celluloid.logger.warn(string) if Celluloid.logger
-    end
-
-    # Send an error message
-    def error(string)
-      Celluloid.logger.error(string) if Celluloid.logger
-    end
-
-    # Handle a crash
-    def crash(string, exception)
-      string << "\n" << format_exception(exception)
-      error string
-
-      @exception_handlers.each do |handler|
-        begin
-          handler.call(exception)
-        rescue => ex
-          error "EXCEPTION HANDLER CRASHED:\n" << format_exception(ex)
-        end
-      end
-    end
-
-    # Note a deprecation
-    def deprecate(message)
-      trace = caller.join("\n\t")
-      warn "DEPRECATION WARNING: #{message}\n\t#{trace}"
-    end
-
-    # Define an exception handler
-    # NOTE: These should be defined at application start time
-    def exception_handler(&block)
-      @exception_handlers << block
-      nil
-    end
-
-    # Format an exception message
-    def format_exception(exception)
-      str = "#{exception.class}: #{exception.to_s}\n\t"
-      if exception.backtrace
-        str << exception.backtrace.join("\n\t")
-      else
-        str << "EMPTY BACKTRACE\n\t"
-      end
-    end
-  end
-end

data/lib/celluloid/logging/incident.rb

@@ -1,21 +0,0 @@
-module Celluloid
-  # Wraps all events and context for a single incident.
-  class Incident
-    attr_accessor :pid
-    attr_accessor :events, :triggering_event
-
-    def initialize(events, triggering_event=nil)
-      @events = events
-      @triggering_event = triggering_event
-      @pid = $$
-    end
-
-    # Merge two incidents together. This may be useful if two incidents occur at the same time.
-    def merge(*other_incidents)
-      merged_events = other_incidents.flatten.inject(events) do |events, incident|
-        events += incident.events
-      end
-      Incident.new(merged_events.sort, triggering_event)
-    end
-  end
-end

data/lib/celluloid/logging/incident_logger.rb

@@ -1,129 +0,0 @@
-require 'logger'
-module Celluloid
-  # A logger that holds all messages in circular buffers, then flushes the buffers
-  # when an event occurs at a configurable severity threshold.
-  #
-  # Unlike ruby's Logger, this class only supports a single progname.
-  class IncidentLogger
-    module Severity
-      include ::Logger::Severity
-
-      TRACE = -1
-
-      def severity_to_string(severity)
-        case severity
-        when TRACE   then 'TRACE'
-        when DEBUG   then 'DEBUG'
-        when INFO    then 'INFO'
-        when WARN    then 'WARN'
-        when ERROR   then 'ERROR'
-        when FATAL   then 'FATAL'
-        when UNKNOWN then 'UNKNOWN'
-        end
-      end
-
-    end
-    include Severity
-
-    # The progname (facility) for this instance.
-    attr_accessor :progname
-
-    # The logging level. Messages below this severity will not be logged at all.
-    attr_accessor :level
-
-    # The incident threshold. Messages at or above this severity will generate an
-    # incident and be published to incident reporters.
-    attr_accessor :threshold
-
-    # The buffer size limit. Each log level will retain this number of messages
-    # at maximum.
-    attr_accessor :sizelimit
-
-    attr_accessor :buffers
-
-    # Create a new IncidentLogger.
-    def initialize(progname=nil, options={})
-      @progname = progname || "default"
-      @level = options[:level] || DEBUG
-      @threshold = options[:threshold] || ERROR
-      @sizelimit = options[:sizelimit] || 100
-
-      @buffer_mutex = Mutex.new
-      @buffers = Hash.new do |progname_hash, _progname|
-        @buffer_mutex.synchronize do
-          progname_hash[_progname] = Hash.new do |severity_hash, severity|
-            severity_hash[severity] = RingBuffer.new(@sizelimit)
-          end
-        end
-      end
-
-      # When the IncidentLogger itself encounters an error, it falls back to logging to stderr
-      @fallback_logger = ::Logger.new(STDERR)
-      @fallback_logger.progname = "FALLBACK"
-    end
-
-    # add an event.
-    def add(severity, message=nil, progname=nil, &block)
-      progname ||= @progname
-      severity ||= UNKNOWN
-
-      if severity < @level
-        return event.id
-      end
-
-      if message.nil? && !block_given?
-        message = progname
-        progname = @progname
-      end
-
-      event = LogEvent.new(severity, message, progname, &block)
-
-      @buffers[progname][severity] << event
-
-      if severity >= @threshold
-        begin
-          Celluloid::Notifications.notifier.async.publish(incident_topic, create_incident(event))
-        rescue => ex
-          @fallback_logger.error(ex)
-        end
-      end
-      event.id
-    end
-    alias :log :add
-
-    # See docs for Logger#info
-    def trace   (progname=nil, &block); add(TRACE,   nil, progname, &block); end
-    def debug   (progname=nil, &block); add(DEBUG,   nil, progname, &block); end
-    def info    (progname=nil, &block); add(INFO,    nil, progname, &block); end
-    def warn    (progname=nil, &block); add(WARN,    nil, progname, &block); end
-    def error   (progname=nil, &block); add(ERROR,   nil, progname, &block); end
-    def fatal   (progname=nil, &block); add(FATAL,   nil, progname, &block); end
-    def unknown (progname=nil, &block); add(UNKNOWN, nil, progname, &block); end
-
-    def flush
-      messages = []
-      @buffer_mutex.synchronize do
-        @buffers.each do |progname, severities|
-          severities.each do |severity, buffer|
-            messages += buffer.flush
-          end
-        end
-      end
-      messages.sort
-    end
-
-    def clear
-      @buffer_mutex.synchronize do
-        @buffers.each { |buffer| buffer.clear }
-      end
-    end
-
-    def create_incident(event=nil)
-      Incident.new(flush, event)
-    end
-
-    def incident_topic
-      "log.incident.#{@progname}"
-    end
-  end
-end

data/lib/celluloid/logging/incident_reporter.rb

@@ -1,48 +0,0 @@
-require 'logger'
-module Celluloid
-  # Subscribes to log incident topics to report on them.
-  class IncidentReporter
-    include Celluloid
-    include Celluloid::Notifications
-
-    # get the time from the event
-    class Formatter < ::Logger::Formatter
-      def call(severity, time, progname, msg)
-        super(severity, msg.time, progname, msg.message)
-      end
-    end
-
-    def initialize(*args)
-      subscribe(/log\.incident/, :report)
-      @logger = ::Logger.new(*args)
-      @logger.formatter = Formatter.new
-      @silenced = false
-    end
-
-    def report(topic, incident)
-      return if @silenced
-
-      header = "INCIDENT"
-      header << " AT #{incident.triggering_event.time}" if incident.triggering_event
-      @logger << header
-      @logger << "\n"
-      @logger << "====================\n"
-      incident.events.each do |event|
-        @logger.add(event.severity, event, event.progname)
-      end
-      @logger << "====================\n"
-    end
-
-    def silence
-      @silenced = true
-    end
-
-    def unsilence
-      @silenced = false
-    end
-
-    def silenced?
-      @silenced
-    end
-  end
-end

data/lib/celluloid/logging/log_event.rb

@@ -1,20 +0,0 @@
-module Celluloid
-  # Wraps a single log event.
-  class LogEvent
-    attr_accessor :id, :severity, :message, :progname, :time
-
-    def initialize(severity, message, progname, time=Time.now, &block)
-      # This id should be ordered. For now relies on Celluloid::UUID to be ordered.
-      # May want to use a generation/counter strategy for independence of uuid.
-      @id = Celluloid::UUID.generate
-      @severity = severity
-      @message = block_given? ? yield : message
-      @progname = progname
-      @time = time
-    end
-
-    def <=>(other)
-      @id <=> other.id
-    end
-  end
-end

data/lib/celluloid/logging/ring_buffer.rb

@@ -1,65 +0,0 @@
-module Celluloid
-  class RingBuffer
-    def initialize(size)
-      @size = size
-      @start = 0
-      @count = 0
-      @buffer = Array.new(size)
-      @mutex = Mutex.new
-    end
-
-    def full?
-      @count == @size
-    end
-
-    def empty?
-      @count == 0
-    end
-
-    def push(value)
-      @mutex.synchronize do
-        stop = (@start + @count) % @size
-        @buffer[stop] = value
-        if full?
-          @start = (@start + 1) % @size
-        else
-          @count += 1
-        end
-        value
-      end
-    end
-    alias :<< :push
-
-    def shift
-      @mutex.synchronize do
-        remove_element
-      end
-    end
-
-    def flush
-      values = []
-      @mutex.synchronize do
-        while !empty?
-          values << remove_element
-        end
-      end
-      values
-    end
-
-    def clear
-      @buffer = Array.new(@size)
-      @start = 0
-      @count = 0
-    end
-
-    private
-
-    def remove_element
-      return nil if empty?
-      value, @buffer[@start] = @buffer[@start], nil
-      @start = (@start + 1) % @size
-      @count -= 1
-      value
-    end
-  end
-end

data/lib/celluloid/method.rb

@@ -1,32 +0,0 @@
-module Celluloid
-  # Method handles that route through an actor proxy
-  class Method
-
-    def initialize(proxy, name)
-      raise NameError, "undefined method `#{name}'" unless proxy.respond_to? name
-
-      @proxy, @name = proxy, name
-      @klass = @proxy.class
-    end
-
-    def arity
-      @proxy.method_missing(:method, @name).arity
-    end
-
-    def name
-      @proxy.method_missing(:method, @name).name
-    end
-
-    def parameters
-      @proxy.method_missing(:method, @name).parameters
-    end
-
-    def call(*args, &block)
-      @proxy.__send__(@name, *args, &block)
-    end
-
-    def inspect
-      "#<Celluloid::Method #{@klass}##{@name}>"
-    end
-  end
-end