fluentd 0.10.35 → 0.10.36

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - rbx-19mode
+
+branches:
+  only:
+    - master
+
+script: bundle exec rake test

data/ChangeLog

@@ -1,3 +1,12 @@
+Release 0.10.36 - 2013/07/31
+
+* Log: add class name on each error logs
+* out_foward: change log level of node detachment/recovering/standby-failover from info to warn
+* out_file: add symlink_path parameter to point to latest written file
+* in_forward, in_http, in_unix: add backlog parameter to change resource backlog size
+* add --dry-run option to check fluentd setup without actual run
+* Fluentd now assumes configuration file written in UTF-8
+* update cool.io version to 1.1.1
 
 Release 0.10.35 - 2013/06/12
 

data/fluentd.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency(%q<msgpack>, [">= 0.4.4", "!= 0.5.0", "!= 0.5.1", "!= 0.5.2", "!= 0.5.3", "< 0.6.0"])
   gem.add_runtime_dependency(%q<json>, [">= 1.4.3"])
   gem.add_runtime_dependency(%q<yajl-ruby>, ["~> 1.0"])
-  gem.add_runtime_dependency(%q<cool.io>, ["~> 1.1.0"])
+  gem.add_runtime_dependency(%q<cool.io>, ["~> 1.1.1"])
   gem.add_runtime_dependency(%q<http_parser.rb>, ["~> 0.5.1"])
 
   gem.add_development_dependency(%q<rake>, [">= 0.9.2"])

data/lib/fluent/buffer.rb

@@ -16,288 +16,284 @@
 #    limitations under the License.
 #
 module Fluent
+  class BufferError < StandardError
+  end
 
+  class BufferChunkLimitError < BufferError
+  end
 
-class BufferError < StandardError
-end
-
-class BufferChunkLimitError < BufferError
-end
-
-class BufferQueueLimitError < BufferError
-end
+  class BufferQueueLimitError < BufferError
+  end
 
 
-class Buffer
-  include Configurable
+  class Buffer
+    include Configurable
 
-  def initialize
-    super
-  end
+    def initialize
+      super
+    end
 
-  def configure(conf)
-    super
-  end
+    def configure(conf)
+      super
+    end
 
-  def start
-  end
+    def start
+    end
 
-  def shutdown
-  end
+    def shutdown
+    end
 
-  def before_shutdown(out)
-  end
+    def before_shutdown(out)
+    end
 
-  #def emit(key, data, chain)
-  #end
+    #def emit(key, data, chain)
+    #end
 
-  #def keys
-  #end
+    #def keys
+    #end
 
-  #def push(key)
-  #end
+    #def push(key)
+    #end
 
-  #def pop(out)
-  #end
+    #def pop(out)
+    #end
 
-  #def clear!
-  #end
-end
+    #def clear!
+    #end
+  end
 
 
-class BufferChunk
-  include MonitorMixin
+  class BufferChunk
+    include MonitorMixin
 
-  def initialize(key)
-    super()
-    @key = key
-  end
+    def initialize(key)
+      super()
+      @key = key
+    end
 
-  attr_reader :key
+    attr_reader :key
 
-  #def <<(data)
-  #end
+    #def <<(data)
+    #end
 
-  #def size
-  #end
+    #def size
+    #end
 
-  def empty?
-    size == 0
-  end
+    def empty?
+      size == 0
+    end
 
-  #def close
-  #end
+    #def close
+    #end
 
-  #def purge
-  #end
+    #def purge
+    #end
 
-  #def read
-  #end
+    #def read
+    #end
 
-  #def open
-  #end
+    #def open
+    #end
 
-  def write_to(io)
-    open {|i|
-      FileUtils.copy_stream(i, io)
-    }
-  end
+    def write_to(io)
+      open {|i|
+        FileUtils.copy_stream(i, io)
+      }
+    end
 
-  def msgpack_each(&block)
-    open {|io|
-      u = MessagePack::Unpacker.new(io)
-      begin
-        u.each(&block)
-      rescue EOFError
-      end
-    }
+    def msgpack_each(&block)
+      open {|io|
+        u = MessagePack::Unpacker.new(io)
+        begin
+          u.each(&block)
+        rescue EOFError
+        end
+      }
+    end
   end
-end
 
 
-class BasicBuffer < Buffer
-  include MonitorMixin
+  class BasicBuffer < Buffer
+    include MonitorMixin
 
-  def initialize
-    super
-    @parallel_pop = true
-  end
+    def initialize
+      super
+      @parallel_pop = true
+    end
 
-  def enable_parallel(b=true)
-    @parallel_pop = b
-  end
+    def enable_parallel(b=true)
+      @parallel_pop = b
+    end
 
-  # This configuration assumes plugins to send records to a remote server.
-  # Local file based plugins which should provide more reliability and efficiency
-  # should override buffer_chunk_limit with a larger size.
-  config_param :buffer_chunk_limit, :size, :default => 8*1024*1024
-  config_param :buffer_queue_limit, :integer, :default => 256
+    # This configuration assumes plugins to send records to a remote server.
+    # Local file based plugins which should provide more reliability and efficiency
+    # should override buffer_chunk_limit with a larger size.
+    config_param :buffer_chunk_limit, :size, :default => 8*1024*1024
+    config_param :buffer_queue_limit, :integer, :default => 256
 
-  alias chunk_limit buffer_chunk_limit
-  alias chunk_limit= buffer_chunk_limit=
-  alias queue_limit buffer_queue_limit
-  alias queue_limit= buffer_queue_limit=
+    alias chunk_limit buffer_chunk_limit
+    alias chunk_limit= buffer_chunk_limit=
+    alias queue_limit buffer_queue_limit
+    alias queue_limit= buffer_queue_limit=
 
-  def configure(conf)
-    super
-  end
+    def configure(conf)
+      super
+    end
 
-  def start
-    @queue, @map = resume
-    @queue.extend(MonitorMixin)
-  end
+    def start
+      @queue, @map = resume
+      @queue.extend(MonitorMixin)
+    end
 
-  def shutdown
-    synchronize do
-      @queue.synchronize do
-        until @queue.empty?
-          @queue.shift.close
+    def shutdown
+      synchronize do
+        @queue.synchronize do
+          until @queue.empty?
+            @queue.shift.close
+          end
         end
+        @map.each_pair {|key,chunk|
+          chunk.close
+        }
       end
-      @map.each_pair {|key,chunk|
-        chunk.close
-      }
     end
-  end
-
-  def emit(key, data, chain)
-    key = key.to_s
 
-    synchronize do
-      top = (@map[key] ||= new_chunk(key))  # TODO generate unique chunk id
+    def emit(key, data, chain)
+      key = key.to_s
 
-      if top.size + data.bytesize <= @buffer_chunk_limit
-        chain.next
-        top << data
-        return false
+      synchronize do
+        top = (@map[key] ||= new_chunk(key))  # TODO generate unique chunk id
 
-      ## FIXME
-      #elsif data.bytesize > @buffer_chunk_limit
-      #  # TODO
-      #  raise BufferChunkLimitError, "received data too large"
+        if top.size + data.bytesize <= @buffer_chunk_limit
+          chain.next
+          top << data
+          return false
 
-      elsif @queue.size >= @buffer_queue_limit
-        raise BufferQueueLimitError, "queue size exceeds limit"
-      end
+          ## FIXME
+          #elsif data.bytesize > @buffer_chunk_limit
+          #  # TODO
+          #  raise BufferChunkLimitError, "received data too large"
 
-      if data.bytesize > @buffer_chunk_limit
-        $log.warn "Size of the emitted data exceeds buffer_chunk_limit."
-        $log.warn "This may occur problems in the output plugins ``at this server.``"
-        $log.warn "To avoid problems, set a smaller number to the buffer_chunk_limit"
-        $log.warn "in the forward output ``at the log forwarding server.``"
-      end
+        elsif @queue.size >= @buffer_queue_limit
+          raise BufferQueueLimitError, "queue size exceeds limit"
+        end
 
-      nc = new_chunk(key)  # TODO generate unique chunk id
-      ok = false
+        if data.bytesize > @buffer_chunk_limit
+          $log.warn "Size of the emitted data exceeds buffer_chunk_limit."
+          $log.warn "This may occur problems in the output plugins ``at this server.``"
+          $log.warn "To avoid problems, set a smaller number to the buffer_chunk_limit"
+          $log.warn "in the forward output ``at the log forwarding server.``"
+        end
 
-      begin
-        nc << data
-        chain.next
+        nc = new_chunk(key)  # TODO generate unique chunk id
+        ok = false
+
+        begin
+          nc << data
+          chain.next
+
+          flush_trigger = false
+          @queue.synchronize {
+            enqueue(top)
+            flush_trigger = @queue.empty?
+            @queue << top
+            @map[key] = nc
+          }
+
+          ok = true
+          return flush_trigger
+        ensure
+          nc.purge unless ok
+        end
 
-        flush_trigger = false
-        @queue.synchronize {
-          enqueue(top)
-          flush_trigger = @queue.empty?
-          @queue << top
-          @map[key] = nc
-        }
+      end  # synchronize
+    end
 
-        ok = true
-        return flush_trigger
-      ensure
-        nc.purge unless ok
-      end
+    def keys
+      @map.keys
+    end
 
-    end  # synchronize
-  end
+    def queue_size
+      @queue.size
+    end
 
-  def keys
-    @map.keys
-  end
+    def total_queued_chunk_size
+      total = 0
+      @map.each_value {|c|
+        total += c.size
+      }
+      @queue.each {|c|
+        total += c.size
+      }
+      total
+    end
 
-  def queue_size
-    @queue.size
-  end
+    #def new_chunk(key)
+    #end
 
-  def total_queued_chunk_size
-    total = 0
-    @map.each_value {|c|
-      total += c.size
-    }
-    @queue.each {|c|
-      total += c.size
-    }
-    total
-  end
+    #def resume
+    #end
 
-  #def new_chunk(key)
-  #end
+    #def enqueue(chunk)
+    #end
 
-  #def resume
-  #end
+    def push(key)
+      synchronize do
+        top = @map[key]
+        if !top || top.empty?
+          return false
+        end
 
-  #def enqueue(chunk)
-  #end
+        @queue.synchronize do
+          enqueue(top)
+          @queue << top
+          @map.delete(key)
+        end
 
-  def push(key)
-    synchronize do
-      top = @map[key]
-      if !top || top.empty?
-        return false
-      end
+        return true
+      end  # synchronize
+    end
 
+    def pop(out)
+      chunk = nil
       @queue.synchronize do
-        enqueue(top)
-        @queue << top
-        @map.delete(key)
+        if @parallel_pop
+          chunk = @queue.find {|c| c.try_mon_enter }
+          return false unless chunk
+        else
+          chunk = @queue.first
+          return false unless chunk
+          return false unless chunk.try_mon_enter
+        end
       end
 
-      return true
-    end  # synchronize
-  end
+      begin
+        if !chunk.empty?
+          write_chunk(chunk, out)
+        end
+
+        @queue.delete_if {|c|
+          c.object_id == chunk.object_id
+        }
+
+        chunk.purge
 
-  def pop(out)
-    chunk = nil
-    @queue.synchronize do
-      if @parallel_pop
-        chunk = @queue.find {|c| c.try_mon_enter }
-        return false unless chunk
-      else
-        chunk = @queue.first
-        return false unless chunk
-        return false unless chunk.try_mon_enter
+        return !@queue.empty?
+      ensure
+        chunk.mon_exit
       end
     end
 
-    begin
-      if !chunk.empty?
-        write_chunk(chunk, out)
-      end
+    def write_chunk(chunk, out)
+      out.write(chunk)
+    end
 
-      @queue.delete_if {|c|
-        c.object_id == chunk.object_id
+    def clear!
+      @queue.delete_if {|chunk|
+        chunk.purge
+        true
       }
-
-      chunk.purge
-
-      return !@queue.empty?
-    ensure
-      chunk.mon_exit
     end
   end
-
-  def write_chunk(chunk, out)
-    out.write(chunk)
-  end
-
-  def clear!
-    @queue.delete_if {|chunk|
-      chunk.purge
-      true
-    }
-  end
-end
-
-
 end