timber 1.0.8 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e48b303535350b36a68d4af296da5a9ee1ddfe1
-  data.tar.gz: accd259a2827a8a466e5cb2aadfc93ac8d350cb9
+  metadata.gz: 2388bf1db8a727e78be858eb8ed03fd1dec10f95
+  data.tar.gz: 392fe3ea6f24f874849cad8ccc015ce989e67fda
 SHA512:
-  metadata.gz: 2f4bf4cf69e07973acc22b59892bcb0b33c76af23de8023fa6fde65807752d7f2d5739ecbed720e0c344bf2c14eda2b994772ec0450fc36c40922d9681e65ea1
-  data.tar.gz: 5917a43860fe36328e1a5246596eca5124ce4a4ca589f41a7b1a3da529484c5b04fab5760f96e98d74f64e90a75b782b7188f2057aa6d2423705a9f03f151ed4
+  metadata.gz: 856d7ebf1f309b905899dd8136a9af9ce60cab4d4c88c6d1b02009cc6b0677b51932366f22d4abdd4fd4f662e90f44021f8a9240f10a7c8a6886eddaf8ee417b
+  data.tar.gz: 24384bcea4caa8d460e1b4eab07047e2c6c94a181110d8b16c47eb1f672abdde6f8158e36a3e7bcf121410e1532e63083b810834d3ec7641c113d608ce1b215c

data/README.md

@@ -10,8 +10,12 @@
 [![View docs](https://img.shields.io/badge/docs-viewdocs-blue.svg?style=flat-square "Viewdocs")](http://www.rubydoc.info/github/timberio/timber-ruby)
 
 
+**Timber is in beta testing. If interested, please email beta@timber.io**
+
+
 1. [What is timber?](#what-is-timber)
-2. [Why timber?](#why-timber)
+2. [How it works](#how-it-works)
+3. [Why timber?](#why-timber)
 4. [Logging Custom Events](#logging-custom-events)
 5. [The Timber Console / Pricing](#the-timber-console--pricing)
 6. [Install](#install)
@@ -19,11 +23,22 @@
 
 ## What is Timber?
 
-[Timber](http://timber.io) is a different kind of logging platform; it goes beyond traditional
-logging by automatically enriching your logs with application level metadata, turning them
-into rich, structured events without altering the essence of logging.
+Using your logs shouldn't be a time consuming, frustrating process! If you were like us, it goes
+something like this:
+
+> How do I access my logs? Which provider should I use? Why is it so expensive?
+> Why is searching so difficult and time consuming? Should I structure my logs? Which format
+> should I use? Will they still be human readable? What if the structure changes? What about logs
+> from 3rd party libraries? Ahhh!!!
+
+Timber solves this by providing a complete, managed, end-to-end logging solution that marries
+a beautiful, *fast*, console with libraries that automatically structure and enrich your logs.
 
-For example, it turns this:
+
+## How it works
+
+The Timber ruby library takes care of all of the log structuring madness. For example,
+it turns this Rails log line:
 
 ```
 Completed 200 OK in 117ms (Views: 85.2ms | ActiveRecord: 25.3ms)
@@ -58,8 +73,10 @@ Into this:
 }
 ```
 
-It does the same for `http requests`, `sql queries`, `exceptions`, `template renderings`,
-and any other event your framework logs.
+Notice we preserve the original log message. When viewing this event in the
+[Timber Console](https://timber.io), you'll see the simple, human readable line with the
+ability to view, and use, the attached structured data! Also, notice how rich the event is.
+Beecause we're inside your application, we can capture data beyond what's in the log line.
 
 (for a full list see [`Timber::Events`](lib/timber/events))
 
@@ -68,13 +85,14 @@ and any other event your framework logs.
 
 Glad you asked! :)
 
-1. It's application aware and enriches your logs with data you can't get otherwise.
-2. It defines a shared schema across all of our libraries. Meaning your log data, across all
-   applications, is normalized.
-3. It does not alter the original log message, giving you the best of both worlds: human
-   readable logs *and* rich structured events.
-4. It's completely transparent with absolutely no vendor lock-in or risk of code debt. It
-   does not introduce a special API, it's just good ol' loggin'.
+1. Human readable logs *and* rich structured data. You don't have to choose.
+2. Data beyond what's in the log line itself making your logs exceptionally useful.
+3. Normalized log data. Timber enforces a strict schema, meaning your log data, across all apps
+   and languages will be normalized.
+4. Absolutely no lock-in or risk of code debt. No fancy API, no proprietary data format locked
+   away in our servers, Timber is just good ol' loggin'.
+5. Fully managed, all the way from the log messages to the console you use. No fragile parsing
+   rules or complicated interfaces.
 
 
 ## Logging Custom Events
@@ -89,7 +107,7 @@ Logger.warn "Payment rejected for customer abcd1234, reason: Card expired"
 
 # Structured hash
 Logger.warn message: "Payment rejected", type: :payment_rejected,
-  data: %{customer_id: "abcd1234", amount: 100, reason: "Card expired"}
+  data: {customer_id: "abcd1234", amount: 100, reason: "Card expired"}
 
 # Using a Struct
 PaymentRejectedEvent = Struct.new(:customer_id, :amount, :reason) do
@@ -108,8 +126,8 @@ No mention of Timber anywhere!
 
 > What good is structured log data if you can't search and visualize it?
 
-Enter [the Timber Console](https://timber.io). It's a modern, fast, and beautiful console for
-searching and visualizing your logs.
+The [Timber Console](https://timber.io) is *fast*, modern, and beautiful console designed
+specifically for this library.
 
 A few example queries:
 
@@ -120,7 +138,7 @@ A few example queries:
 
 > This is all gravy, but wouldn't the extra data get expensive?
 
-If you opt use the [Timber Console](https://timber.io), we only charge for
+If you opt to use the [Timber Console](https://timber.io), we only charge for
 the size of the `message`, `dt`, and `event.custom` attributes. Everything else is
 stored at no cost to you. [Say wha?!](http://i.giphy.com/l0HlL2vlfpWI0meJi.gif). This ensures
 pricing remains predictable. We charge per GB sent to us and retained. No user limits,
@@ -131,6 +149,8 @@ For more details checkout out [timber.io](https://timber.io).
 
 ## Install
 
+**Timber is in beta testing. If interested, please email beta@timber.io**
+
 ### 1. Install the gem:
 
 ```ruby

data/lib/timber/log_devices/http.rb

@@ -1,130 +1,229 @@
-require "timber/log_devices/http/triggered_buffer"
-
 module Timber
   module LogDevices
-    # A log device that buffers and delivers log messages over HTTPS to the Timber API in batches.
-    # The buffer and delivery strategy are very efficient and the log messages will be delivered in
-    # msgpack format.
+    # A log device that buffers and delivers log messages over HTTPS to the Timber API.
+    # It uses batches, keep-alive connections, and messagepack to delivery logs with
+    # high-throughput and little overhead.
     #
     # See {#initialize} for options and more details.
     class HTTP
-      API_URI = URI.parse(ENV["TIMBER_INGESTION_URL"] || "https://logs.timber.io/frames")
-      CONTENT_TYPE = "application/x-timber-msgpack-frame-1".freeze
-      CONNECTION_HEADER = "keep-alive".freeze
-      USER_AGENT = "Timber Ruby Gem/#{Timber::VERSION}".freeze
-      HTTPS = Net::HTTP.new(API_URI.host, API_URI.port).tap do |https|
-        https.use_ssl = true
-        https.read_timeout = 30
-        https.ssl_timeout = 10
-        # Ruby 1.9.X doesn't have this setting.
-        if https.respond_to?(:keep_alive_timeout=)
-          https.keep_alive_timeout = 60
+      # @private
+      class LogMsgQueue
+        MAX_MSG_BYTES = 50_000 # 50kb
+
+        def initialize(max_bytes)
+          @lock = Mutex.new
+          @max_bytes = max_bytes
+          @array = []
+          @bytesize = 0
+        end
+
+        def enqueue(msg)
+          if msg.bytesize > MAX_MSG_BYTES
+            raise ArgumentError.new("Log message exceeds the #{MAX_MSG_BYTES} bytes limit")
+          end
+
+          @lock.synchronize do
+            @array << msg
+            @bytesize += msg.bytesize
+          end
+        end
+
+        def flush
+          @lock.synchronize do
+            old = @array
+            @array = []
+            @bytesize = 0
+            return old
+          end
+        end
+
+        def full?
+          @lock.synchronize do
+            @bytesize >= @max_bytes
+          end
+        end
+
+        def size
+          @array.size
+        end
+      end
+
+      # Works like SizedQueue, but drops message instead of blocking. Pass one of these in
+      # to {HTTP#intiialize} via the :request_queue option if you'd prefer to drop messages
+      # in the event of a buffer overflow instead of applying back pressure.
+      class DroppingSizedQueue < SizedQueue
+        # Returns true/false depending on whether the queue is full or not
+        def push(obj)
+          @mutex.synchronize do
+            return false unless @que.length < @max
+
+            @que.push obj
+            begin
+              t = @waiting.shift
+              t.wakeup if t
+            rescue ThreadError
+              retry
+            end
+            return true
+          end
         end
-        https.open_timeout = 10
       end
+
+      TIMBER_URL = "https://logs.timber.io/frames".freeze
+      CONTENT_TYPE = "application/x-timber-msgpack-frame-1".freeze
+      USER_AGENT = "Timber Ruby Gem/#{Timber::VERSION}".freeze
       DELIVERY_FREQUENCY_SECONDS = 2.freeze
-      RETRY_LIMIT = 3.freeze
+      RETRY_LIMIT = 5.freeze
       BACKOFF_RATE_SECONDS = 3.freeze
 
 
       # Instantiates a new HTTP log device that can be passed to {Timber::Logger#initialize}.
       #
+      # The class maintains a buffer which is flushed in batches to the Timber API. 2
+      # options control when the flush happens, `:batch_byte_size` and `:flush_interval`.
+      # If either of these are surpassed, the buffer will be flushed.
+      #
+      # By default, the buffer will apply back pressure log messages are generated faster than
+      # the client can delivery them. But you can drop messages instead by passing a
+      # {DroppingSizedQueue} via the `:request_queue` option.
+      #
       # @param api_key [String] The API key provided to you after you add your application to
       #   [Timber](https://timber.io).
       # @param [Hash] options the options to create a HTTP log device with.
-      # @option attributes [Symbol] :payload_limit_bytes Determines the maximum size in bytes that
-      #   and HTTP payload can be. Please see {TriggereBuffer#initialize} for the default.
-      # @option attributes [Symbol] :buffer_limit_bytes Determines the maximum size of the total
-      #   buffer. This should be many times larger than the `:payload_limit_bytes`.
-      #   Please see {TriggereBuffer#initialize} for the default.
-      # @option attributes [Symbol] :buffer_overflow_handler (nil) When a single message exceeds
-      #   `:payload_limit_bytes` or the entire buffer exceeds `:buffer_limit_bytes`, the Proc
-      #   passed to this option will be called with the msg that would overflow the buffer. See
-      #   the examples on how to use this properly.
-      # @option attributes [Symbol] :delivery_frequency_seconds (2) How often the client should
-      #   attempt to deliver logs to the Timber API. The HTTP client buffers logs between calls.
+      # @option attributes [Symbol] :batch_byte_size Determines the maximum size in bytes for
+      #   each HTTP payload. If the buffer exceeds this limit a delivery will be attempted.
+      # @option attributes [Symbol] :debug Whether to print debug output or not. This is also
+      #   inferred from ENV['debug']. Output will be sent to `Timber::Config.logger`.
+      # @option attributes [Symbol] :flush_interval (2) How often the client should
+      #   attempt to deliver logs to the Timber API. The HTTP client buffers logs and this
+      #   options represents how often that will happen, assuming `:batch_byte_size` is not met.
+      # @option attributes [Symbol] :requests_per_conn The number of requests to send over a
+      #   single persistent connection. After this number is met, the connection will be closed
+      #   and a new one will be opened.
+      # @option attributes [Symbol] :request_queue The request queue object that queues Net::HTTP
+      #   requests for delivery. By deafult this is a `SizedQueue` of size `3`. Meaning once
+      #   3 requests are placed on the queue for delivery, back pressure will be applied. IF
+      #   you'd prefer to drop messages instead, pass a {DroppingSizedQueue}. See examples for
+      #   an example.
+      # @option attributes [Symbol] :timber_url The Timber URL to delivery the log lines. The
+      #   default is set via {TIMBER_URL}.
       #
       # @example Basic usage
       #   Timber::Logger.new(Timber::LogDevices::HTTP.new("my_timber_api_key"))
       #
-      # @example Handling buffer overflows
-      #   # Persist overflowed lines to a file
-      #   # Note: You could write these to any permanent storage.
-      #   overflow_log_path = "/path/to/my/overflow_log.log"
-      #   overflow_handler = Proc.new { |log_line_msg| File.write(overflow_log_path, log_line_ms) }
+      # @example Dropping messages instead of applying back pressure
       #   http_log_device = Timber::LogDevices::HTTP.new("my_timber_api_key",
-      #     buffer_overflow_handler: overflow_handler)
+      #     request_queue: Timber::LogDevices::HTTP::DroppingSizedQueue.new(3))
       #   Timber::Logger.new(http_log_device)
       def initialize(api_key, options = {})
         @api_key = api_key
-        @buffer = TriggeredBuffer.new(
-          payload_limit_bytes: options[:payload_limit_bytes],
-          limit_bytes: options[:buffer_limit_bytes],
-          overflow_handler: options[:buffer_overflow_handler]
-        )
-        @delivery_interval_thread = Thread.new do
-          loop do
-            sleep(options[:delivery_frequency_seconds] || DELIVERY_FREQUENCY_SECONDS)
-
-            @last_messages_overflow_count = 0
-            messages_overflown_count = @buffer.messages_overflown_count
-            if messages_overflown_count >= @last_messages_overflow_count
-              difference = messages_overflown_count - @last_messages_overflow_count
-              @last_messages_overflow_count = messages_overflown_count
-              logger.warn("Timber HTTP buffer has overflown #{difference} times")
-            end
+        @debug = options[:debug] || ENV['debug']
+        @timber_url = URI.parse(options[:timber_url] || ENV['TIMBER_URL'] || TIMBER_URL)
+        @batch_byte_size = options[:batch_byte_size] || 3_000_000 # 3mb
+        @flush_interval = options[:flush_interval] || 2 # 2 seconds
+        @requests_per_conn = options[:requests_per_conn] || 1_000
+        @msg_queue = LogMsgQueue.new(@batch_byte_size)
+        @request_queue = options[:request_queue] || SizedQueue.new(3)
+        @req_in_flight = 0
 
-            buffer_for_delivery = @buffer.reserve
-            if buffer_for_delivery
-              deliver(buffer_for_delivery)
-            end
-          end
+        if options[:threads] != false
+          @outlet_thread = Thread.new { outlet }
+          @flush_thread = Thread.new { intervaled_flush }
         end
       end
 
       # Write a new log line message to the buffer, and deliver if the msg exceeds the
       # payload limit.
       def write(msg)
-        buffer_for_delivery = @buffer.write(msg)
-        if buffer_for_delivery
-          deliver(buffer_for_delivery)
+        @msg_queue.enqueue(msg)
+        if @msg_queue.full?
+          flush
         end
         true
       end
 
       # Closes the log device, cleans up, and attempts one last delivery.
       def close
-        @delivery_interval_thread.kill
-        buffer_for_delivery = @buffer.reserve
-        if buffer_for_delivery
-          deliver(buffer_for_delivery)
-        end
+        @flush_thread.kill if @flush_thread
+        @outlet_thread.kill if @outlet_thread
+        flush
       end
 
       private
-        def deliver(body)
-          Thread.new do
-            RETRY_LIMIT.times do |try_index|
-              request = Net::HTTP::Post.new(API_URI.request_uri).tap do |req|
-                req['Authorization'] = authorization_payload
-                req['Connection'] = CONNECTION_HEADER
-                req['Content-Type'] = CONTENT_TYPE
-                req['User-Agent'] = USER_AGENT
-                req.body = body
+        def debug?
+          !@debug.nil?
+        end
+
+        def flush
+          msgs = @msg_queue.flush
+          return if msgs.empty?
+
+          body = ""
+          msgs.each do |msg|
+            body << msg
+          end
+
+          req = Net::HTTP::Post.new(@timber_url.path)
+          req['Authorization'] = authorization_payload
+          req['Content-Type'] = CONTENT_TYPE
+          req['User-Agent'] = USER_AGENT
+          req.body = body
+          @request_queue.enq(req)
+          @last_flush = Time.now
+        end
+
+        def intervaled_flush
+          # Wait specified time period before starting
+          sleep @flush_interval
+          loop do
+            begin
+              if intervaled_flush_ready?
+                flush
               end
+              sleep(0.1)
+            rescue Exception => e
+              logger.error("Timber intervaled flush failed: #{e.inspect}")
+            end
+          end
+        end
+
+        def intervaled_flush_ready?
+          @last_flush.nil? || (Time.now.to_f - @last_flush.to_f).abs >= @flush_interval
+        end
+
+        def outlet
+          loop do
+            http = Net::HTTP.new(@timber_url.host, @timber_url.port)
+            http.set_debug_output(logger) if debug?
+            http.use_ssl = true if @timber_url.scheme == 'https'
+            http.read_timeout = 30
+            http.ssl_timeout = 10
+            http.open_timeout = 10
 
-              res = HTTPS.request(request)
-              code = res.code.to_i
-              if code < 200 || code >= 300
-                try = try_index + 1
-                logger.debug("Timber HTTP delivery failed, try #{try} - #{res.code}: #{res.body}")
-                sleep(try * BACKOFF_RATE_SECONDS)
-              else
-                @buffer.remove(body)
-                logger.debug("Timber HTTP delivery successful - #{code}")
-                logger.debug("Timber new buffer size - #{@buffer.total_bytesize}")
-                break # exit the loop
+            begin
+              http.start do |conn|
+                num_reqs = 0
+                while num_reqs < @requests_per_conn
+                  #Blocks waiting for a request.
+                  req = @request_queue.deq
+                  @req_in_flight += 1
+                  resp = nil
+                  begin
+                    resp = conn.request(req)
+                  rescue => e
+                    logger.error("Timber request error: #{e.message}") if debug?
+                    next
+                  ensure
+                    @req_in_flight -= 1
+                  end
+                  num_reqs += 1
+                  logger.info("Timber request successful: #{resp.code}") if debug?
+                end
               end
+            rescue => e
+              logger.error("Timber request error: #{e.message}") if debug?
+            ensure
+              http.finish if http.started?
             end
           end
         end

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "1.0.8"
+  VERSION = "1.0.9"
 end

data/spec/timber/log_devices/http_spec.rb

@@ -2,33 +2,31 @@ require "spec_helper"
 
 describe Timber::LogDevices::HTTP do
   describe "#initialize" do
-    it "should start a thread for delivery" do
-      expect_any_instance_of(described_class).to receive(:deliver).at_least(1).times.and_return(true)
-      http = described_class.new("MYKEY", delivery_frequency_seconds: 0.1)
-      thread = http.instance_variable_get(:@delivery_interval_thread)
+    it "should initialize properly" do
+      http = described_class.new("MYKEY", flush_interval: 0.1)
+      thread = http.instance_variable_get(:@flush_thread)
+      expect(thread).to be_alive
+      thread = http.instance_variable_get(:@flush_thread)
       expect(thread).to be_alive
-
-      http.write("my log message")
-      sleep 0.3 # too fast!
     end
   end
 
   describe "#write" do
     let(:http) { described_class.new("MYKEY") }
-    let(:buffer) { http.instance_variable_get(:@buffer) }
+    let(:msg_queue) { http.instance_variable_get(:@msg_queue) }
 
     it "should buffer the messages" do
       http.write("test log message")
-      expect(buffer.reserve).to eq("test log message")
+      expect(msg_queue.flush).to eq(["test log message"])
     end
 
-    context "with a low payload limit" do
-      let(:http) { described_class.new("MYKEY", :payload_limit_bytes => 20) }
+    context "with a low batch byte size" do
+      let(:http) { described_class.new("MYKEY", :batch_byte_size => 20) }
 
       it "should attempt a delivery when the payload limit is exceeded" do
         message = "a" * 19
         http.write(message)
-        expect(http).to receive(:deliver).exactly(1).times.with(message)
+        expect(http).to receive(:flush).exactly(1).times
         http.write("my log message")
       end
     end
@@ -37,9 +35,12 @@ describe Timber::LogDevices::HTTP do
   describe "#close" do
     let(:http) { described_class.new("MYKEY") }
 
-    it "should kill the delivery thread the messages" do
+    it "should kill the threads" do
       http.close
-      thread = http.instance_variable_get(:@delivery_interval_thread)
+      thread = http.instance_variable_get(:@flush_thread)
+      sleep 0.1 # too fast!
+      expect(thread).to_not be_alive
+      thread = http.instance_variable_get(:@outlet_thread)
       sleep 0.1 # too fast!
       expect(thread).to_not be_alive
     end
@@ -47,39 +48,57 @@ describe Timber::LogDevices::HTTP do
     it "should attempt a delivery" do
       message = "a" * 19
       http.write(message)
-      expect(http).to receive(:deliver).exactly(1).times.with(message)
+      expect(http).to receive(:flush).exactly(1).times
       http.close
     end
   end
 
-  describe "#deliver" do
-    let(:http) { described_class.new("MYKEY") }
+  # Testing a private method because it helps break down our tests
+  describe "#flush" do
+    it "should add a request to the queue" do
+      http = described_class.new("MYKEY", threads: false)
+      http.write("This is a log message")
+      http.send(:flush)
+      request_queue = http.instance_variable_get(:@request_queue)
+      request = request_queue.deq
+      expect(request).to be_kind_of(Net::HTTP::Post)
+      expect(request.body).to eq("This is a log message")
 
-    after(:each) { http.close }
+      message_queue = http.instance_variable_get(:@msg_queue)
+      expect(message_queue.size).to eq(0)
+    end
+  end
+
+  # Testing a private method because it helps break down our tests
+  describe "#intervaled_flush" do
+    it "should start a intervaled flush thread and flush on an interval" do
+      http = described_class.new("MYKEY", flush_interval: 0.1)
+      expect(http).to receive(:flush).exactly(1).times
+      sleep 0.15 # too fast!
+      mock = expect(http).to receive(:flush).exactly(1).times
+      sleep 0.15 # too fast!
+    end
+  end
 
-    it "should delivery properly and flush the buffer" do
+  # Outlet
+  describe "#outlet" do
+    it "should start a intervaled flush thread and flush on an interval" do
       stub = stub_request(:post, "https://logs.timber.io/frames").
         with(
-          :body => "test log message",
+          :body => 'test log message',
           :headers => {
             'Authorization' => 'Basic TVlLRVk=',
-            'Connection' => 'keep-alive',
             'Content-Type' => 'application/x-timber-msgpack-frame-1',
             'User-Agent' => "Timber Ruby Gem/#{Timber::VERSION}"
           }
         ).
         to_return(:status => 200, :body => "", :headers => {})
 
+      http = described_class.new("MYKEY", flush_interval: 0.1)
       http.write("test log message")
-      buffer = http.instance_variable_get(:@buffer)
-      buffers = buffer.instance_variable_get(:@buffers)
-      expect(buffers.size).to eq(1)
-      body = buffer.reserve
-      thread = http.send(:deliver, body)
-      thread.join
+      sleep 0.2
 
       expect(stub).to have_been_requested.times(1)
-      expect(buffers.size).to eq(0)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timber
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.9
 platform: ruby
 authors:
 - Timber Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-16 00:00:00.000000000 Z
+date: 2016-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -62,7 +62,6 @@ files:
 - lib/timber/frameworks/rails.rb
 - lib/timber/log_devices.rb
 - lib/timber/log_devices/http.rb
-- lib/timber/log_devices/http/triggered_buffer.rb
 - lib/timber/log_entry.rb
 - lib/timber/logger.rb
 - lib/timber/probe.rb
@@ -95,7 +94,6 @@ files:
 - spec/support/timecop.rb
 - spec/support/webmock.rb
 - spec/timber/events_spec.rb
-- spec/timber/log_devices/http/triggered_buffer_spec.rb
 - spec/timber/log_devices/http_spec.rb
 - spec/timber/logger_spec.rb
 - spec/timber/probes/action_controller_log_subscriber_spec.rb
@@ -143,7 +141,6 @@ test_files:
 - spec/support/timecop.rb
 - spec/support/webmock.rb
 - spec/timber/events_spec.rb
-- spec/timber/log_devices/http/triggered_buffer_spec.rb
 - spec/timber/log_devices/http_spec.rb
 - spec/timber/logger_spec.rb
 - spec/timber/probes/action_controller_log_subscriber_spec.rb

data/lib/timber/log_devices/http/triggered_buffer.rb

@@ -1,87 +0,0 @@
-require "monitor"
-
-module Timber
-  module LogDevices
-    class HTTP
-      # Maintains a triggered buffer, where the trigger is {PAYLOAD_LIMIT_BYTES}. Once the buffer
-      # exceeds this limit it will lock and return that buffer up to that point while still making
-      # a new buffer available for writes. This ensures that the HTTP client can attempt to deliver
-      # the buffer contents without blocking execution of the application.
-      #
-      # If the overall buffer exceeeds the overall limit (specified by the `:limit_bytes` option),
-      # then a buffer overflow is triggered. This can be customized using the `:overflow_handler`
-      # option.
-      class TriggeredBuffer
-        DEFAULT_PAYLOAD_LIMIT_BYTES = 5_000_000 # 5mb, the Timber API will not accept messages larger than this
-        DEFAULT_LIMIT_BYTES = 50_000_000 # 50mb
-
-        attr_reader :messages_overflown_count
-
-        def initialize(options = {})
-          @buffers = []
-          @monitor = Monitor.new
-          @payload_limit_bytes = options[:payload_limit_bytes] || DEFAULT_PAYLOAD_LIMIT_BYTES
-          @limit_bytes = options[:limit_bytes] || DEFAULT_LIMIT_BYTES
-          @overflow_handler = options[:overflow_handler]
-          @messages_overflown_count = 0
-        end
-
-        def write(msg)
-          if msg.bytesize > @payload_limit_bytes || (msg.bytesize + total_bytesize) > @limit_bytes
-            handle_overflow(msg)
-            return nil
-          end
-
-          @monitor.synchronize do
-            buffer = writable_buffer
-            if @buffers == [] || buffer.nil? || buffer.frozen?
-              @buffers << msg
-              nil
-            elsif (buffer.bytesize + msg.bytesize) > @payload_limit_bytes
-              @buffers << msg
-              buffer.freeze
-            else
-              buffer << msg
-              nil
-            end
-          end
-        end
-
-        def reserve
-          @monitor.synchronize do
-            buffer = writable_buffer
-            if buffer
-              buffer.freeze
-            end
-          end
-        end
-
-        def remove(buffer)
-          @monitor.synchronize do
-            @buffers.delete(buffer)
-          end
-        end
-
-        def total_bytesize
-          @buffers.reduce(0) { |acc, buffer| acc + buffer.bytesize }
-        end
-
-        private
-          def writable_buffer
-            @buffers.find { |buffer| !buffer.frozen? }
-          end
-
-          def handle_overflow(msg)
-            @messages_overflown_count += 1
-            if @overflow_handler
-              @overflow_handler.call(msg)
-            end
-          end
-
-          def logger
-            Config.instance.logger
-          end
-      end
-    end
-  end
-end

data/spec/timber/log_devices/http/triggered_buffer_spec.rb

@@ -1,58 +0,0 @@
-require "spec_helper"
-
-describe Timber::LogDevices::HTTP::TriggeredBuffer do
-  describe "#write" do
-    it "should trigger a buffer overflow for large messages" do
-      buffer = described_class.new(:payload_limit_bytes => 10)
-      msg = "a" * 11
-      expect(buffer).to receive(:handle_overflow).exactly(1).times.with(msg)
-      buffer.write(msg)
-    end
-
-    it "should trigger a buffer overflow when exceeding the limit" do
-      buffer = described_class.new(:limit_bytes => 10)
-      msg = "a" * 11
-      expect(buffer).to receive(:handle_overflow).exactly(1).times.with(msg)
-      buffer.write(msg)
-    end
-
-    it "should start a new buffer when empty and append when not" do
-      buffer = described_class.new
-      result = buffer.write("test")
-      expect(result).to be_nil
-      expect(buffer.send(:writable_buffer)).to eq("test")
-      result = buffer.write("again")
-      expect(result).to be_nil
-      expect(buffer.send(:writable_buffer)).to eq("testagain")
-    end
-
-    it "should return the old buffer when it has exceeded it's limit" do
-      buffer = described_class.new(:payload_limit_bytes => 10)
-      msg = "a" * 6
-      result = buffer.write(msg)
-      expect(result).to be_nil
-      result = buffer.write(msg)
-      expect(result).to eq(msg)
-      expect(result).to be_frozen
-    end
-
-    it "should write a new buffer when the latest is frozen" do
-      buffer = described_class.new
-      buffer.write("test")
-      result = buffer.reserve
-      expect(result).to eq("test")
-      buffer.write("again")
-      expect(buffer.send(:writable_buffer)).to eq("again")
-    end
-  end
-
-  describe "#reserve" do
-    it "should reserve the latest buffer and freeze it" do
-      buffer = described_class.new
-      buffer.write("test")
-      result = buffer.reserve
-      expect(result).to eq("test")
-      expect(result).to be_frozen
-    end
-  end
-end