lpxc 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab326ae043382498e355d1c8c27cc3642a9dca80
-  data.tar.gz: 7e1ad3efa4fc3f1a9fdfe461d36f3866e535d9a3
+  metadata.gz: a9a59ea66505168840a485b178c9f805df781f4b
+  data.tar.gz: 1181f1e2976a3a6a0fccf4e88a006c66bca90815
 SHA512:
-  metadata.gz: da1649d6fe13116634cbc9ed1aad344835e8051c5a335d5dc6483995d27cf4fb6e2045a6da1944dc76ffdffcd2055a4b99fccc951ed3583c32461b36aab22df2
-  data.tar.gz: 15492414fc68c9a15c872cce993bcea64c39667b8cecaa235ebac4d3a24c50249ce261c263d7151f5e3ccd65666a8c56db3e4ba0647612e793a0ebbd396dab23
+  metadata.gz: 2c7f0c812aa0f867262d7e178bafa9e804704d0493d5951b65334d479253c3566162cbde8a6ebd9c82f4534e0b650d5780d7bee6b721aee27d57b48d411d02ff
+  data.tar.gz: ef326d1790d550779e7c6e86851228d0dc16fc1da8e87b735ce7a05dab91154ba99291184212c2134b2a6a644f39f983fc757376a47c5f34ab4b2ce7f3362dde

data/lib/lpxc.rb

@@ -4,6 +4,30 @@ require 'uri'
 require 'thread'
 require 'timeout'
 
+class LogMsgQueue
+  def initialize(max)
+    @locker = Mutex.new
+    @max = max
+    @array = []
+  end
+
+  def enqueue(msg)
+    @locker.synchronize {@array << msg}
+  end
+
+  def flush
+    @locker.synchronize do
+      old = @array
+      @array = []
+      return old
+    end
+  end
+
+  def full?
+    @locker.synchronize {@array.size >= @max}
+  end
+end
+
 class Lpxc
 
   #After parsing opts and initializing defaults, the initializer
@@ -50,24 +74,19 @@ class Lpxc
     Thread.new {delay_flush} if opts[:disable_delay_flush].nil?
   end
 
-  # The interface to publish logs into the stream.
-  # This function will set the log message to the current time in UTC.
-  # If the buffer for this token's log msgs is full, it will flush the buffer.
-  # You can specify a logplex token for the message, otherwise #puts will fall
-  # back on the default_token specified in the initializer. If default_token
-  # was not specified in the initializer, then the user portion of the
-  # LOGPLEX_URL will be used.
-  def puts(msg, tok=nil)
+  #The interface to publish logs into the stream.
+  #This function will set the log message to the current time in UTC.
+  #If the buffer for this token's log messages is full, it will flush the buffer.
+  def puts(msg, tok=@default_token)
+    q = nil
     @hash_lock.synchronize do
       #Messages are grouped by their token since 1 http request
       #to logplex must only contain log messages belonging to a single token.
-      q = @hash[tok] ||= SizedQueue.new(@batch_size)
-      #This call will block if the queue is full.
-      #However this should never happen since the next command will flush
-      #the queue if we add the last item.
-      q.enq({:t => Time.now.utc, :token => (tok || default_token), :msg => msg})
-      flush if q.size == q.max
+      q = @hash[tok] ||= LogMsgQueue.new(@batch_size)
     end
+    q.enqueue({:t => Time.now.utc, :token => tok, :msg => msg})
+    # Flush all of the queues if any queue is full.
+    flush if q.full?
   end
 
   #Wait until all of the data has been cleared from memory.
@@ -80,22 +99,25 @@ class Lpxc
       @req_in_flight.zero?
   end
 
-  private
-
-  def default_token
-    @default_token || @logplex_url.user
+  # Empty all log messages into a request queue. Messages will be grouped
+  # by token such that each request contains messages with homogeneus tokens.
+  # A seperate thread will process the requests.
+  def flush
+    to_be_processed = nil
+    @hash_lock.synchronize do
+      to_be_processed = @hash
+      @hash = {}
+    end
+    process_hash(to_be_processed)
   end
 
-  #Take a lock to read all of the buffered messages.
-  #Once we have read the messages, we make 1 http request for the batch.
-  #We pass the request off into the request queue so that the request
-  #can be sent to LOGPLEX_URL.
-  def flush
-    @hash.each do |tok, msgs|
+  private
+
+  def process_hash(h)
+    h.each do |tok, queue|
       #Copy the messages from the queue into the payload array.
-      payloads = []
-      msgs.size.times {payloads << msgs.deq}
-      return if payloads.nil? || payloads.empty?
+      payloads = queue.flush
+      next if payloads.nil? || payloads.empty?
 
       #Use the payloads array to build a string that will be
       #used as the http body for the logplex request.
@@ -107,16 +129,14 @@ class Lpxc
       #Build a new HTTP request and place it into the queue
       #to be processed by the HTTP connection.
       req = Net::HTTP::Post.new(@logplex_url.path)
-      req.basic_auth("token", @logplex_url.user)
+      req.basic_auth("token", tok)
       req.add_field('Content-Type', 'application/logplex-1')
       req.body = body
       @request_queue.enq(req)
-      @hash.delete(tok)
       @last_flush = Time.now
     end
   end
 
-
   #This method must be called in order for the messages to be sent to Logplex.
   #This method also spawns a thread that allows the messages to be batched.
   #Messages are flushed from memory every 500ms or when we have 300 messages,
@@ -124,9 +144,7 @@ class Lpxc
   def delay_flush
     loop do
       begin
-        if interval_ready?
-          @hash_lock.synchronize {flush}
-        end
+        flush if interval_ready?
         sleep(0.01)
       rescue => e
         $stderr.puts("at=start-error error=#{e.message}") if ENV['DEBUG']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lpxc
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Ryan Smith (♠ ace hacker)