timber 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a6efcc9b1ff96b7bfea713d3e87e36b7bfc061fd
-  data.tar.gz: 6ef8b32449171a85062421fc42da7c4417b7fdf8
+  metadata.gz: fbf04b7803b278fe7386975994f5c16d019b125b
+  data.tar.gz: 27b112405610ebb0b2c948ba4e1ae0f698fd5ac0
 SHA512:
-  metadata.gz: 79c590f521790d5f24349bdfb2cd9058cd78b18955bfa61164338d75b70cb7e58a24594a31f93780af6a1f27bbafd124c5a3249d3dac9d331debfb3181792e63
-  data.tar.gz: 6e284e8801b5e9643fe36e65200f1425c2da8ab078a6bb60f29339323da86ef371f7ca8a32634f8f7d22932672422e35bc4883e59f814ae06d131503a08ec076
+  metadata.gz: a474845f4dc5c7c328d860458ce93d5a2769cd850ebb7117cf442662565ab654e1c57f3a209037d43f80a8f5b0b27e54cebfb581f6505aad8f0939c8e14285a1
+  data.tar.gz: 0f60bc9a972900139d780a22c9c10c0e35afaa46689c5cc8a4bacd22ee1db454fbb34f3ef003d5a92a070255c7f309d0c2fcd3e38e4ffce6c48bfbdff9de2f96

data/README.md

@@ -1,41 +1,28 @@
-# 🌲 Timber - Simple Ruby Structured Logging
+# 🌲 Timber - Log Better. Solve Problems Faster.
 
 [![ISC License](https://img.shields.io/badge/license-ISC-ff69b4.svg)](LICENSE.md)
+[![Hex.pm](https://img.shields.io/hexpm/v/timber.svg?maxAge=18000=plastic)](https://hex.pm/packages/timber)
+[![Documentation](https://img.shields.io/badge/hexdocs-latest-blue.svg)](https://hexdocs.pm/timber/index.html)
 [![Build Status](https://travis-ci.org/timberio/timber-ruby.svg?branch=master)](https://travis-ci.org/timberio/timber-ruby)
-[![Code Climate](https://codeclimate.com/github/timberio/timber-ruby/badges/gpa.svg)](https://codeclimate.com/github/timberio/timber-ruby)
-[![View docs](https://img.shields.io/badge/docs-viewdocs-blue.svg?style=flat-square "Viewdocs")](http://www.rubydoc.info/github/timberio/timber-ruby)
-
-* [Timber website](https://timber.io)
-* [Timber docs](https://timber.io/docs)
-* [Library docs](http://www.rubydoc.info/github/timberio/timber-ruby)
-* [Support](mailto:support@timber.io)
-
 
 ## Overview
 
-Timber solves ruby structured logging so you don't have to. Go from raw text logs to rich
-structured events in seconds. Spend more time focusing on your app and less time
-focusing on logging.
-
-1. **Easy setup.** - `bundle exec timber install`, [get setup in seconds](#installation).
-
-2. **Automatically structures yours logs.** - Third-party and in-app logs are all structured
-   in a consistent format. See [how it works](#how-it-works) below.
+[Timber](https://timber.io) is a logging platform with one major difference: Instead of parsing,
+which relies on unreadable, unpredictable, hard to use text logs, Timber integrates directly with
+your application, producing rich structured events containing metadata and context you couldn't
+capture otherwise. It fundamentally changes the way you use your logs.
 
-3. **Seamlessly integrates with popular libraries and frameworks.** - Rails, Rack, Devise,
-   Omniauth, etc. [Automatically captures user context, HTTP context, and event data.](#third-party-integrations)
-
-4. **Pairs with a modern structured-logging console.** - Designed specifically for structured data,
-   hosted, instantly usable, tail users, trace requests.
-   [Checkout the docs](https://timber.io/docs/app/tutorials/).
+1. [**Easy setup** - `mix timber.install`](#installation)
+2. [**Seamlessly integrates with popular libraries and frameworks**](#jibber-jabber)
+3. [**Modern fast console, designed specifically for your application**](#the-timber-console)
 
 
 ## Installation
 
-1. In `Gemfile`, add the `timber` gem:
+1. In your `Gemfile`, add the `timber` gem:
 
     ```ruby
-    gem 'timber', '~> 2.0'
+    gem 'timber', '~> 2.1'
     ```
 
 2. In your `shell`, run `bundle install`
@@ -43,95 +30,6 @@ focusing on logging.
 3. In your `shell`, run `bundle exec timber install`
 
 
-## How it works
-
-Let's start with an example. Timber turns this production log line:
-
-```
-I, [2017-06-04T18:04:53.653812 #42348]  INFO -- : [my.host.com] [df88dbaa-50fd-4178-85d7-d66279ea33b6] [192.32.23.12] [bfa8242cd9733bf0211e334be203f0d0] Sent 200 in 45.2ms
-```
-
-Into a structured [`http_server_response` event](https://timber.io/docs/ruby/events-and-context/http-server-response-event/).
-
-```
-Sent 200 in 45.2ms @metadata {"dt": "2017-02-02T01:33:21.154345Z", "level": "info", "context": {"http": {"method": "GET", "path": "/path", "remote_addr": "192.32.23.12", "request_id": "df88dbaa-50fd-4178-85d7-d66279ea33b6"}, "session": {"id": "bfa8242cd9733bf0211e334be203f0d0"}, "system": {"hostname": "my.host.com", "pid": "254354"}, "user": {"id": 1, "name": "Ben Johnson", "email": "bens@email.com"}}, "event": {"http_server_response": {"status": 200, "time_ms": 45.2}}}
-```
-
-Notice that instead of completely replacing your log messages,
-Timber _augments_ your logs with structured metadata. Turning them into
-[rich events with context](https://timber.io/docs/ruby/events-and-context) without sacrificing
-readability. And you have [complete control over which data is captured](#configuration).
-
-This is all accomplished by using the
-[Timber::Logger](http://www.rubydoc.info/github/timberio/timber-ruby/Timber/Logger):
-
-```ruby
-logger = Timber::Logger.new(STDOUT)
-logger.info("Sent 200 in 45.2ms")
-```
-
-Here's a better look at the metadata:
-
-```js
-{
-  "dt": "2017-02-02T01:33:21.154345Z",
-  "level": "info",
-  "context": {
-    "http": {
-      "method": "GET",
-      "path": "/path",
-      "remote_addr": "192.32.23.12",
-      "request_id": "abcd1234"
-    },
-    "session": {
-      "id": "bfa8242cd9733bf0211e334be203f0d0"
-    },
-    "system": {
-      "hostname": "1.server.com",
-      "pid": "254354"
-    },
-    "user": { // user identifiable logs :O
-      "id": 1,
-      "name": "Ben Johnson",
-      "email": "bens@email.com"
-    },
-  },
-  "event": {
-    "http_server_response": {
-      "status": 200,
-      "time_ms": 45.2
-    }
-  }
-}
-```
-
-This structure isn't arbitrary either, it follows the
-[simple log event JSON schema](https://github.com/timberio/log-event-json-schema), which
-formalizes the data structure, creates a contract with downstream consumers, and
-improves stability.
-
-So what can you do with this data?
-
-1. [**Tail a user** - `user.id:1`](https://timber.io/docs/app/tutorials/tail-a-user/)
-2. [**Trace a request** - `http.request_id:abcd1234`](https://timber.io/docs/app/tutorials/view-in-request-context/)
-3. **Narrow by host** - `system.hostname:1.server.com`
-4. **View slow responses** - `http_server_response.time_ms:>=1000`
-5. **Filter by log level** - `level:error`
-6. **Quickly find exceptions** - `is:exception`
-
-For a complete overview, see the [Timber for Ruby docs](https://timber.io/docs/ruby/overview/).
-
-
-## Third-party integrations
-
-1. **Rails**: Structures ([HTTP requests](https://timber.io/docs/ruby/events-and-context/http-server-request-event/), [HTTP respones](https://timber.io/docs/ruby/events-and-context/http-server-response-event/), [controller calls](https://timber.io/docs/ruby/events-and-context/controller-call-event/), [template renders](https://timber.io/docs/ruby/events-and-context/template-render-event/), and [sql queries](https://timber.io/docs/ruby/events-and-context/sql-query-event/)).
-2. **Rack**: Structures [exceptions](https://timber.io/docs/ruby/events-and-context/exception-event/), captures [HTTP context](https://timber.io/docs/ruby/events-and-context/http-context/), captures [user context](https://timber.io/docs/ruby/events-and-context/user-context/), captures [session context](https://timber.io/docs/ruby/events-and-context/session-context/).
-3. **Devise, Omniauth, Clearance**: captures [user context](https://timber.io/docs/ruby/events-and-context/user-context/)
-5. **Heroku**: Captures [release context](https://timber.io/docs/ruby/events-and-context/release-context/) via [Heroku dyno metadata](https://devcenter.heroku.com/articles/dyno-metadata).
-
-...and more. Timber will continue to evolve and support more libraries.
-
-
 ## Usage
 
 <details><summary><strong>Basic logging</strong></summary><p>
@@ -139,7 +37,6 @@ For a complete overview, see the [Timber for Ruby docs](https://timber.io/docs/r
 Use the `Timber::Logger` just like you would `::Logger`:
 
 ```ruby
-logger = Timber::Logger.new(STDOUT)
 logger.info("My log message") # use warn, error, debug, etc.
 
 # => My log message @metadata {"level": "info", "context": {...}}
@@ -155,7 +52,6 @@ Custom events allow you to extend beyond events already defined in
 the [`Timber::Events`](lib/timber/events) namespace.
 
 ```ruby
-logger = Timber::Logger.new(STDOUT)
 logger.warn "Payment rejected", payment_rejected: {customer_id: "abcd1234", amount: 100, reason: "Card expired"}
 
 # => Payment rejected @metadata {"level": "warn", "event": {"payment_rejected": {"customer_id": "abcd1234", "amount": 100, "reason": "Card expired"}}, "context": {...}}
@@ -163,7 +59,7 @@ logger.warn "Payment rejected", payment_rejected: {customer_id: "abcd1234", amou
 
 * Notice the `:payment_rejected` root key. Timber will classify this event as such.
 * In the [Timber console](https://app.timber.io) use the query: `type:payment_rejected` or `payment_rejected.amount:>100`.
-* See more details on our [custom events docs page](https://timber.io/docs/ruby/custom-events/)
+* See more details on our [custom events docs page](https://timber.io/docs/ruby/usage/custom-events/)
 
 ---
 
@@ -177,7 +73,6 @@ Custom contexts allow you to extend beyond contexts already defined in
 the [`Timber::Contexts`](lib/timber/contexts) namespace.
 
 ```ruby
-logger = Timber::Logger.new(STDOUT)
 logger.with_context(build: {version: "1.0.0"}) do
   logger.info("My log message")
 end
@@ -187,7 +82,7 @@ end
 
 * Notice the `:build` root key. Timber will classify this context as such.
 * In the [Timber console](https://app.timber.io) use queries like: `build.version:1.0.0`
-* See more details on our [custom contexts docs page](https://timber.io/docs/ruby/custom-contexts/)
+* See more details on our [custom contexts docs page](https://timber.io/docs/ruby/usage/custom-contexts/)
 
 ---
 
@@ -204,7 +99,6 @@ Here's a timing example. Notice how Timber automatically calculates the time and
 to the message.
 
 ```ruby
-logger = Timber::Logger.new(STDOUT)
 timer = Timber::Timer.start
 # ... code to time ...
 logger.info("Processed background job", background_job: {time_ms: timer})
@@ -221,7 +115,6 @@ logger.info("Processed background job", background_job: {time_ms: 45.6})
 Lastly, metrics aren't limited to timings. You can capture any metric you want:
 
 ```ruby
-logger = Timber::Logger.new(STDOUT)
 logger.info("Credit card charged", credit_card_charge: {amount: 123.23})
 
 # => Credit card charged @metadata {"level": "info", "event": {"credit_card_charge": {"amount": 123.23}}}
@@ -331,7 +224,6 @@ Simply set the formatter like you would with any other logger:
 
 ```ruby
 # This is set in your various environment files
-logger = Timber::Logger.new(STDOUT)
 logger.formatter = Timber::Logger::JSONFormatter.new
 ```
 
@@ -407,60 +299,68 @@ All variables are optional, but at least one must be present.
 
 ## Jibber-Jabber
 
-<details><summary><strong>Which events and contexts does Timber capture for me?</strong></summary><p>
+<details><summary><strong>Which log events does Timber structure for me?</strong></summary><p>
 
-Out of the box you get everything in the
-[`Timber::Events`](http://www.rubydoc.info/github/timberio/timber-ruby/Timber/Events) namespace.
+Out of the box you get everything in the [`Timber.Events`](lib/timber/events) namespace.
 
-We also add context to every log, everything in the
-[`Timber::Contexts`](http://www.rubydoc.info/github/timberio/timber-ruby/Timber/Contexts)
+We also add context to every log, everything in the [`Timber.Contexts`](lib/timber/contexts)
 namespace. Context is structured data representing the current environment when the log line
-was written. It is included in every log line. Think of it like join data for your logs. It's
-how Timber is able to accomplished tailing users (`context.user.id:1`).
-
-Lastly, you can checkout how we capture these events in
-[`Timber::Integrations`](lib/timber/integrations).
+was written. It is included in every log line. Think of it like join data for your logs.
 
 ---
 
 </p></details>
 
-<details><summary><strong>Won't this increase the size of my log data?</strong></summary><p>
+<details><summary><strong>What about my current log statements?</strong></summary><p>
 
-Yes, but it's no different than adding any other useful data to your logs, such as
-[tags](http://api.rubyonrails.org/classes/ActiveSupport/TaggedLogging.html). A few
-of things to note:
+They'll continue to work as expected. Timber adheres strictly to the default `Logger` interface
+and will never deviate in *any* way.
 
-1. Timber generally _reduces_ the amount of logs your app generates, trading quality for quantity.
-   It does so by providing options to consolidate request / response logs, template logs, and
-   even silence logs that are not of value to you. (see [configuration](#configuration) for examples).
-2. Timber lets you pick exactly which events and contexts you want.
-   (see [configuration](#configuration) for examples)
-3. Your logging provider should be compressing your data and charging you accordingly. Log data
-   is notoriously repetitive, and the context Timber generates is repetitive.
-   Because of compression we've seen somes apps only incur a ~15% increase in data size.
+In fact, traditional log statements for non-meaningful events, debug statements, etc, are
+encouraged. In cases where the data is meaningful, consider [logging a custom event](#usage).
 
-Finally, log what is useful to you. Quality over quantity certainly applies to logging.
+</p></details>
 
----
+<details><summary><strong>When to use metadata or events?</strong></summary><p>
 
-</p></details>
+At it's basic level, both metadata and events serve the same purpose: they add structured
+data to your logs. And anyone that's implemented structured logging know's this can quickly get
+out of hand. This is why we created events. Here's how we recommend using them:
 
-<details><summary><strong>What about my current log statements?</strong></summary><p>
+1. Use `events` when the log cleanly maps to an event that you'd like to alert on, graph, or use
+   in a meaningful way. Typically something that is core to your business or application.
+2. Use metadata for debugging purposes; when you simply want additional insight without
+   polluting the message.
 
-They'll continue to work as expected. Timber adheres to the default `::Logger` interface.
-Your previous logger calls will work as they always do. Just swap in `Timber::Logger` and
-you're good to go.
+### Example 1: Logging that a payment was rejected
 
-In fact, traditional log statements for non-meaningful events, debug statements, etc, are
-encouraged. In cases where the data is meaningful, consider [logging a custom event](#usage).
+This is clearly an event that is meaningful to your business. You'll probably want to alert and
+graph this data. So let's log it as an official event:
+
+```ruby
+logger.info("Payment rejected", payment_rejected: {customer_id: "xiaus1934", amount: 1900, currency: "USD"})
+```
+
+### Example 2: Logging that an email was changed
+
+This is definitely log worthy, but not something that is core to your business or application.
+Instead of an event, use metadata:
+
+```ruby
+logger.info("Email successfully changed", old_email: old_email, new_email: new_email)
+```
 
 ---
 
 </p></details>
 
----
+
+## The Timber Console
+
+[![Timber Console](http://files.timber.io/images/readme-interface7.gif)](https://app.timber.io)
+
+## Your Moment of Zen
 
 <p align="center" style="background: #221f40;">
-<a href="http://github.com/timberio/timber-elixir"><img src="http://files.timber.io/images/ruby-library-readme-log-truth.png" height="947" /></a>
-</p>
+<a href="http://github.com/timberio/timber-ruby"><img src="http://files.timber.io/images/readme-log-truth.png" height="947" /></a>
+</p>

data/lib/timber/config.rb

@@ -36,7 +36,7 @@ module Timber
 
     # @private
     def initialize
-      @http_body_limit = 2000
+      @http_body_limit = 2048
     end
 
     # Convenience method for logging debug statements to the debug logger
@@ -130,16 +130,15 @@ module Timber
       @http_header_filters ||= []
     end
 
-    # Truncates captured HTTP bodies to this specified limit. The default is `2000`.
-    # If you want to capture more data, you can raise this to a maximum of `5000`,
-    # or lower this to be more efficient with data. `2000` characters should give you a good
-    # idea of the body content. If you need to raise to `5000` you're only constraint is
-    # network throughput.
+    # Truncates captured HTTP bodies to this specified limit. The default is `2048`.
+    # If you want to capture more data, you can raise this to a maximum of `8192`,
+    # or lower this to be more efficient with data. `2048` characters should give you a good
+    # idea of the body content.
     #
     # @example Rails
-    #   config.timber.http_body_limit = 500
+    #   config.timber.http_body_limit = 2048
     # @example Everything else
-    #   Timber::Config.instance.http_body_limit = 500
+    #   Timber::Config.instance.http_body_limit = 2048
     def http_body_limit=(value)
       @http_body_limit = value
     end

data/lib/timber/config/integrations/rack.rb

@@ -14,15 +14,15 @@ module Timber
       module Rack
         extend self
 
-        # Convenience method for accessing the {Timber::Integrations::Rack::ExceptionEvent}
+        # Convenience method for accessing the {Timber::Integrations::Rack::ErrorEvent}
         # middleware class specific configuration. See {Timber::Integrations::Rack::ExceptionEvent}
         # for a list of methods available.
         #
         # @example
         #   config = Timber::Config.instance
-        #   config.integrations.rack.exception_event.enabled = false
-        def exception_event
-          Timber::Integrations::Rack::ExceptionEvent
+        #   config.integrations.rack.error_event.enabled = false
+        def error_event
+          Timber::Integrations::Rack::ErrorEvent
         end
 
         # Convenience method for accessing the {Timber::Integrations::Rack::HTTPContext}

data/lib/timber/contexts/runtime.rb

@@ -9,7 +9,7 @@ module Timber
     class Runtime < Context
       @keyspace = :runtime
 
-      attr_reader :application, :class_name, :file, :function, :line, :module_name
+      attr_reader :application, :class_name, :file, :function, :line, :module_name, :vm_pid
 
       def initialize(attributes)
         @application = attributes[:application]
@@ -18,12 +18,13 @@ module Timber
         @function = attributes[:function]
         @line = attributes[:line]
         @module_name = attributes[:module_name]
+        @vm_pid = attributes[:vm_pid]
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
       def as_json(_options = {})
         {application: application, class_name: class_name, file: file, function: function,
-          line: line, module_name: module_name}
+          line: line, module_name: module_name, vm_pid: vm_pid}
       end
     end
   end

data/lib/timber/contexts/system.rb

@@ -15,12 +15,12 @@ module Timber
       def initialize(attributes)
         @hostname = attributes[:hostname]
         @pid = attributes[:pid]
-        @pid = @pid.to_s
+        @pid = Timber::Util::Object.try(@pid, :to_i)
       end
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
       def as_json(_options = {})
-        {hostname: hostname, pid: Timber::Util::Object.try(pid, :to_s)}
+        {hostname: hostname, pid: Timber::Util::Object.try(pid, :to_i)}
       end
     end
   end

data/lib/timber/current_context.rb

@@ -158,6 +158,11 @@ module Timber
         system_context = Contexts::System.new(hostname: hostname, pid: pid)
         add_to!(new_hash, system_context)
 
+        # Runtime context
+        thread_object_id = Thread.current.object_id
+        runtime_context = Contexts::System.new(vm_pid: thread_object_id)
+        add_to!(new_hash, runtime_context)
+
         new_hash
       end
 

data/lib/timber/events.rb

@@ -1,10 +1,8 @@
 require "timber/events/controller_call"
 require "timber/events/custom"
-require "timber/events/exception"
-require "timber/events/http_client_request"
-require "timber/events/http_client_response"
-require "timber/events/http_server_request"
-require "timber/events/http_server_response"
+require "timber/events/error"
+require "timber/events/http_request"
+require "timber/events/http_response"
 require "timber/events/sql_query"
 require "timber/events/template_render"
 

data/lib/timber/events/controller_call.rb

@@ -10,6 +10,7 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionController::LogSubscriber} integration.
     class ControllerCall < Timber::Event
+      PARAMS_JSON_MAX_BYTES = 8192.freeze
       PASSWORD_NAME = 'password'.freeze
 
       attr_reader :controller, :action, :params, :format
@@ -44,11 +45,12 @@ module Timber
 
       private
         def params_json
-          @params_json ||= if params.nil? || params == {}
-            nil
-          else
-            params.to_json
-          end
+          @params_json ||=
+            if params.nil? || params == {}
+              nil
+            else
+              params.to_json.byteslice(0, PARAMS_JSON_MAX_BYTES)
+            end
         end
 
         def sanitize_params(params)

data/lib/timber/events/{exception.rb → error.rb}

@@ -3,38 +3,39 @@ require "timber/util"
 
 module Timber
   module Events
-    # The exception event is used to track exceptions.
+    # The error event is used to track errors and exceptions.
     #
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionDispatch::DebugExceptions} integration.
-    class Exception < Timber::Event
-      attr_reader :name, :exception_message, :backtrace
+    class Error < Timber::Event
+      MAX_MESSAGE_BYTES = 8192.freeze
+
+      attr_reader :name, :error_message, :backtrace
 
       def initialize(attributes)
         @name = attributes[:name] || raise(ArgumentError.new(":name is required"))
-        @exception_message = attributes[:exception_message] || raise(ArgumentError.new(":exception_message is required"))
+
+        @error_message = attributes[:error_message] || raise(ArgumentError.new(":error_message is required"))
+        @error_message = @error_message.byteslice(0, MAX_MESSAGE_BYTES)
 
         backtrace = attributes[:backtrace]
-        if backtrace.nil? || backtrace == []
-          raise(ArgumentError.new(":backtrace is required"))
+        if !backtrace.nil? && backtrace != []
+          @backtrace = backtrace[0..9].collect { |line| parse_backtrace_line(line) }
         end
-
-        # 10 items max
-        @backtrace = backtrace[0..9].collect { |line| parse_backtrace_line(line) }
       end
 
       def to_hash
-        {name: name, message: exception_message, backtrace: backtrace}
+        {name: name, message: error_message, backtrace: backtrace}
       end
       alias to_h to_hash
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
       def as_json(_options = {})
-        {:exception => to_hash}
+        {:error => to_hash}
       end
 
       def message
-        "#{name} (#{exception_message})"
+        "#{name} (#{error_message})"
       end
 
       private

data/lib/timber/events/{http_server_request.rb → http_request.rb}

@@ -8,19 +8,19 @@ module Timber
     #
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionController::LogSubscriber} integration.
-    class HTTPServerRequest < Timber::Event
+    class HTTPRequest < Timber::Event
       attr_reader :body, :headers, :host, :method, :path, :port, :query_string, :request_id,
-        :scheme
+        :scheme, :service_name
 
       def initialize(attributes)
         @body = attributes[:body] && Util::HTTPEvent.normalize_body(attributes[:body])
         @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
-        @host = attributes[:host] || raise(ArgumentError.new(":host is required"))
+        @host = attributes[:host]
         @method = Util::HTTPEvent.normalize_method(attributes[:method]) || raise(ArgumentError.new(":method is required"))
         @path = attributes[:path]
         @port = attributes[:port]
         @query_string = Util::HTTPEvent.normalize_query_string(attributes[:query_string])
-        @scheme = attributes[:scheme] || raise(ArgumentError.new(":scheme is required"))
+        @scheme = attributes[:scheme]
         @request_id = attributes[:request_id]
       end
 
@@ -32,7 +32,7 @@ module Timber
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
       def as_json(_options = {})
-        {:http_server_request => to_hash}
+        {:http_request => to_hash}
       end
 
       def message

data/lib/timber/events/{http_server_response.rb → http_response.rb}

@@ -8,8 +8,8 @@ module Timber
     #
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActionController::LogSubscriber} integration.
-    class HTTPServerResponse < Timber::Event
-      attr_reader :body, :headers, :http_context, :request_id, :status, :time_ms
+    class HTTPResponse < Timber::Event
+      attr_reader :body, :headers, :http_context, :request_id, :service_name, :status, :time_ms
 
       def initialize(attributes)
         @body = attributes[:body] && Util::HTTPEvent.normalize_body(attributes[:body])
@@ -28,7 +28,7 @@ module Timber
 
       # Builds a hash representation containing simple objects, suitable for serialization (JSON).
       def as_json(_options = {})
-        {:http_server_response => to_hash}
+        {:http_response => to_hash}
       end
 
       # Returns the human readable log message for this event.

data/lib/timber/events/sql_query.rb

@@ -7,10 +7,13 @@ module Timber
     # @note This event should be installed automatically through integrations,
     #   such as the {Integrations::ActiveRecord::LogSubscriber} integration.
     class SQLQuery < Timber::Event
+      MAX_QUERY_BYTES = 1024.freeze
+
       attr_reader :sql, :time_ms, :message
 
       def initialize(attributes)
         @sql = attributes[:sql] || raise(ArgumentError.new(":sql is required"))
+        @sql = @sql.byteslice(0, MAX_QUERY_BYTES)
         @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
         @time_ms = @time_ms.round(6)
         @message = attributes[:message] || raise(ArgumentError.new(":message is required"))

data/lib/timber/integrations/action_dispatch.rb

@@ -1,5 +1,5 @@
 require "timber/integration"
-require "timber/integrations/rack/exception_event"
+require "timber/integrations/rack/error_event"
 require "timber/integrations/action_dispatch/debug_exceptions"
 
 module Timber
@@ -10,7 +10,7 @@ module Timber
     # works as expected.
     module ActionDispatch
       def self.enabled?
-        Rack::ExceptionEvent.enabled?
+        Rack::ErrorEvent.enabled?
       end
 
       def self.integrate!

data/lib/timber/integrations/rack.rb

@@ -1,4 +1,4 @@
-require "timber/integrations/rack/exception_event"
+require "timber/integrations/rack/error_event"
 require "timber/integrations/rack/http_context"
 require "timber/integrations/rack/http_events"
 require "timber/integrations/rack/session_context"
@@ -9,7 +9,7 @@ module Timber
     module Rack
       # Enable / disable all Rack middlewares with a single setting.
       def self.enabled=(value)
-        ExceptionEvent.enabled = value
+        ErrorEvent.enabled = value
         HTTPContext.enabled = value
         HTTPEvents.enabled = value
         SessionContext.enabled = value
@@ -20,7 +20,7 @@ module Timber
       # context are added first so that context is included in subsequent log lines.
       def self.middlewares
         @middlewares ||= [HTTPContext, SessionContext, UserContext,
-          HTTPEvents, ExceptionEvent].select(&:enabled?)
+          HTTPEvents, ErrorEvent].select(&:enabled?)
       end
     end
   end

data/lib/timber/integrations/rack/{exception_event.rb → error_event.rb}

@@ -7,16 +7,16 @@ rescue Exception
 end
 
 require "timber/config"
-require "timber/events/exception"
+require "timber/events/error"
 require "timber/integrations/rack/middleware"
 require "timber/util"
 
 module Timber
   module Integrations
     module Rack
-      # A Rack middleware that is reponsible for capturing exceptions events
-      # {Timber::Events::Exception}.
-      class ExceptionEvent < Middleware
+      # A Rack middleware that is reponsible for capturing exception and error events
+      # {Timber::Events::Error}.
+      class ErrorEvent < Middleware
         # We determine this when the app loads to avoid the overhead on a per request basis.
         EXCEPTION_WRAPPER_TAKES_CLEANER = if Gem.loaded_specs["rails"]
           Gem.loaded_specs["rails"].version >= Gem::Version.new('5.0.0')
@@ -31,9 +31,9 @@ module Timber
             Config.instance.logger.fatal do
               backtrace = extract_backtrace(env, exception)
 
-              Events::Exception.new(
+              Events::Error.new(
                 name: exception.class.name,
-                exception_message: exception.message,
+                error_message: exception.message,
                 backtrace: backtrace
               )
             end

data/lib/timber/integrations/rack/http_events.rb

@@ -3,15 +3,15 @@ require "set"
 require "timber/config"
 require "timber/contexts/http"
 require "timber/current_context"
-require "timber/events/http_server_request"
-require "timber/events/http_server_response"
+require "timber/events/http_request"
+require "timber/events/http_response"
 require "timber/integrations/rack/middleware"
 
 module Timber
   module Integrations
     module Rack
       # A Rack middleware that is reponsible for capturing and logging HTTP server requests and
-      # response events. The {Events::HTTPServerRequest} and {Events::HTTPServerResponse} events
+      # response events. The {Events::HTTPRequest} and {Events::HTTPResponse} events
       # respectively.
       class HTTPEvents < Middleware
         class << self
@@ -26,7 +26,7 @@ module Timber
           #    helpful and redundant to the body captured here.
           #
           # If you opt to capture bodies, you can also truncate the size to reduce the data
-          # captured. See {Events::HTTPServerRequest}.
+          # captured. See {Events::HTTPRequest}.
           #
           # @example
           #   Timber::Integrations::Rack::HTTPEvents.capture_request_body = true
@@ -39,7 +39,7 @@ module Timber
             @capture_request_body == true
           end
 
-          # Just like {#capture_request_body=} but for the {Events::HTTPServerResponse} event.
+          # Just like {#capture_request_body=} but for the {Events::HTTPResponse} event.
           # Please see {#capture_request_body=} for more details. The documentation there also
           # applies here.
           def capture_response_body=(value)
@@ -67,9 +67,9 @@ module Timber
           #
           #   Get "/" sent 200 OK in 79ms
           #
-          # The single event is still a {Timber::Events::HTTPServerResponse} event. Because
+          # The single event is still a {Timber::Events::HTTPResponse} event. Because
           # we capture HTTP context, you still get the HTTP details, but you will not get
-          # all of the request details that the {Timber::Events::HTTPServerRequest} event would
+          # all of the request details that the {Timber::Events::HTTPRequest} event would
           # provide.
           #
           # @example
@@ -128,7 +128,7 @@ module Timber
               http_context = CurrentContext.fetch(http_context_key)
               time_ms = (Time.now - start) * 1000.0
 
-              Events::HTTPServerResponse.new(
+              Events::HTTPResponse.new(
                 headers: headers,
                 http_context: http_context,
                 request_id: request.request_id,
@@ -145,7 +145,7 @@ module Timber
             Config.instance.logger.info do
               event_body = capture_request_body? ? request.body_content : nil
 
-              Events::HTTPServerRequest.new(
+              Events::HTTPRequest.new(
                 body: event_body,
                 headers: request.headers,
                 host: request.host,
@@ -164,7 +164,7 @@ module Timber
               time_ms = (Time.now - start) * 1000.0
               event_body = capture_response_body? ? body : nil
 
-              Events::HTTPServerResponse.new(
+              Events::HTTPResponse.new(
                 body: event_body,
                 headers: headers,
                 request_id: request.request_id,

data/lib/timber/log_devices.rb

@@ -1,4 +1,5 @@
 require "timber/log_devices/http"
+require "timber/log_devices/multi"
 
 module Timber
   # Namespace for all log devices.

data/lib/timber/log_devices/http.rb

@@ -214,7 +214,11 @@ module Timber
         def build_http
           http = Net::HTTP.new(@timber_url.host, @timber_url.port)
           http.set_debug_output(Config.instance.debug_logger) if Config.instance.debug_logger
-          http.use_ssl = true if @timber_url.scheme == 'https'
+          if @timber_url.scheme == 'https'
+            http.use_ssl = true
+            # Verification on Windows fails despite having a valid certificate.
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
           http.read_timeout = 30
           http.ssl_timeout = 10
           http.open_timeout = 10

data/lib/timber/log_devices/multi.rb

@@ -0,0 +1,34 @@
+module Timber
+  module LogDevices
+    # @private
+    #
+    # A log device that writes to multiple IO devices.
+    #
+    # Note, you should not have to instantiate this class directly. Simply pass multiple
+    # arguments to the `Timber::Logger#new` method.
+    #
+    # See the {Timber::Logger#new} for examples.
+    class Multi
+      def initialize(targets)
+        @targets = targets
+      end
+
+      def write(*args)
+        @targets.each { |t| t.write(*args) }
+        @targets.first
+      end
+
+      def sync=(value)
+        @targets.each do |t|
+          if t.respond_to?(:sync=)
+            t.sync = value
+          end
+        end
+      end
+
+      def close
+        @targets.each(&:close)
+      end
+    end
+  end
+end

data/lib/timber/log_entry.rb

@@ -8,7 +8,8 @@ module Timber
   # `Logger` and the log device that you set it up with.
   class LogEntry #:nodoc:
     DT_PRECISION = 6.freeze
-    SCHEMA = "https://raw.githubusercontent.com/timberio/log-event-json-schema/v2.0.4/schema.json".freeze
+    MESSAGE_MAX_BYTES = 8192.freeze
+    SCHEMA = "https://raw.githubusercontent.com/timberio/log-event-json-schema/v3.0.7/schema.json".freeze
 
     attr_reader :context_snapshot, :event, :level, :message, :progname, :tags, :time, :time_ms
 
@@ -31,6 +32,7 @@ module Timber
       # This follows the default behavior set by ::Logger
       # See: https://github.com/ruby/ruby/blob/trunk/lib/logger.rb#L615
       @message = message.is_a?(String) ? message : message.inspect
+      @message = @message.byteslice(0, MESSAGE_MAX_BYTES)
       @tags = options[:tags]
       @time_ms = options[:time_ms]
       @context_snapshot = context_snapshot

data/lib/timber/logger.rb

@@ -4,7 +4,7 @@ require "msgpack"
 require "timber/config"
 require "timber/current_context"
 require "timber/event"
-require "timber/log_devices/http"
+require "timber/log_devices"
 require "timber/log_entry"
 
 module Timber
@@ -185,24 +185,50 @@ module Timber
     include ::ActiveSupport::LoggerThreadSafeLevel if defined?(::ActiveSupport::LoggerThreadSafeLevel)
     include ::LoggerSilence if defined?(::LoggerSilence)
 
-    # Creates a new Timber::Logger instances. Accepts the same arguments as `::Logger.new`.
-    # The only difference is that it default the formatter to {AugmentedFormatter}. Using
-    # a different formatter is easy. For example, if you prefer your logs in JSON.
+    # Creates a new Timber::Logger instance where the passed argument is an IO device. That is,
+    # anything that responds to `#write` and `#close`.
     #
-    # @example Changing your formatter
+    # Note, this method does *not* accept the same arguments as the standard Ruby `::Logger`.
+    # The Ruby `::Logger` accepts additional options controlling file rotation if the first argument
+    # is a file *name*. This is a design flaw that Timber does not assume. Logging to a file, or
+    # multiple IO devices is demonstrated in the examples below.
+    #
+    # @example Logging to STDOUT
     #   logger = Timber::Logger.new(STDOUT)
-    #   logger.formatter = Timber::Logger::JSONFormatter.new
-    def initialize(*args)
-      super(*args)
+    #
+    # @example Logging to the Timber HTTP device
+    #   http_device = Timber::LogDevices::HTTP.new("my-timber-api-key")
+    #   logger = Timber::Logger.new(http_device)
+    #
+    # @example Logging to a file (with rotation)
+    #   file_device = Logger::LogDevice.new("path/to/file.log")
+    #   logger = Timber::Logger.new(file_device)
+    #
+    # @example Logging to a file and the Timber HTTP device (multiple log devices)
+    #   http_device = Timber::LogDevices::HTTP.new("my-timber-api-key")
+    #   file_device = Logger::LogDevice.new("path/to/file.log")
+    #   logger = Timber::Logger.new(http_device, file_device)
+    def initialize(*io_devices)
+      io_device = \
+        if io_devices.size == 0
+          raise ArgumentError.new("At least one IO device must be provided when instantiating " +
+            "a Timber::Logger. Ex: Timber::Logger.new(STDOUT).")
+        elsif io_devices.size > 1
+          LogDevices::Multi.new(io_devices)
+        else
+          io_devices.first
+        end
+
+      super(io_device)
 
       # Ensure we sync STDOUT to avoid buffering
-      if args.size == 1 and args.first.respond_to?(:"sync=")
-        args.first.sync = true
+      if io_device.respond_to?(:"sync=")
+        io_device.sync = true
       end
 
       # Set the default formatter. The formatter cannot be set during
       # initialization, and can be changed with #formatter=.
-      if args.size == 1 and args.first.is_a?(LogDevices::HTTP)
+      if io_device.is_a?(LogDevices::HTTP)
         self.formatter = PassThroughFormatter.new
       elsif Config.instance.development? || Config.instance.test?
         self.formatter = MessageOnlyFormatter.new

data/lib/timber/util/http_event.rb

@@ -1,10 +1,9 @@
 module Timber
   module Util
-    # Utility module for dealing with HTTP events {Events::HTTPServerRequest},
-    # {Events::HTTPServerResponse}, {Events::HTTPClientRequest}, {Events::HTTPClientResponse}.
+    # Utility module for dealing with HTTP events {Events::HTTPRequest} and {Events::HTTPResponse}.
     module HTTPEvent
       HEADERS_TO_SANITIZE = ['authorization', 'x-amz-security-token'].freeze
-      QUERY_STRING_LIMIT = 5_000.freeze
+      MAX_QUERY_STRING_BYTES = 2048.freeze
       STRING_CLASS_NAME = 'String'.freeze
 
       extend self
@@ -25,7 +24,7 @@ module Timber
 
         limit = Config.instance.http_body_limit
         if limit
-          body[0..(limit - 1)]
+          body.byteslice(0, limit)
         else
           body
         end
@@ -63,7 +62,7 @@ module Timber
           query_string = query_string.to_s
         end
 
-        query_string && query_string[0..(QUERY_STRING_LIMIT - 1)]
+        query_string && query_string.byteslice(0, MAX_QUERY_STRING_BYTES)
       end
     end
   end

data/lib/timber/version.rb

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "2.1.1"
+  VERSION = "2.1.2"
 end

data/spec/timber/contexts/system_spec.rb

@@ -3,9 +3,9 @@ require "spec_helper"
 describe Timber::Contexts::System, :rails_23 => true do
   describe ".as_json" do
     it "should coerce pid into an string" do
-      custom_context = described_class.new(:pid => 1)
+      custom_context = described_class.new(:pid => "1")
       json = custom_context.as_json()
-      expect(json[:pid]).to eq("1")
+      expect(json[:pid]).to eq(1)
     end
   end
 end

data/spec/timber/events/{exception_spec.rb → error_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Timber::Events::Exception, :rails_23 => true do
+describe Timber::Events::Error, :rails_23 => true do
   describe ".initialize" do
     it "should clean the backtrace" do
       backtrace = [
@@ -8,7 +8,7 @@ describe Timber::Events::Exception, :rails_23 => true do
         "path/to/file2.rb:86:in `function2'"
       ]
 
-      exception_event = described_class.new(name: "RuntimeError", exception_message: "Boom", backtrace: backtrace)
+      exception_event = described_class.new(name: "RuntimeError", error_message: "Boom", backtrace: backtrace)
       expect(exception_event.backtrace).to eq([{:file=>"/path/to/file1.rb", :line=>26, :function=>"function1"}, {:file=>"path/to/file2.rb", :line=>86, :function=>"function2"}])
     end
 
@@ -18,7 +18,7 @@ describe Timber::Events::Exception, :rails_23 => true do
         "path/to/file2.rb:86" # function names are optional
       ]
 
-      exception_event = described_class.new(name: "RuntimeError", exception_message: "Boom", backtrace: backtrace)
+      exception_event = described_class.new(name: "RuntimeError", error_message: "Boom", backtrace: backtrace)
       expect(exception_event.backtrace).to eq([{:file=>"/path/to/file1.rb", :line=>26, :function=>"function1"}, {:file=>"path/to/file2.rb", :line=>86}])
     end
 
@@ -27,7 +27,7 @@ describe Timber::Events::Exception, :rails_23 => true do
         "malformed"
       ]
 
-      exception_event = described_class.new(name: "RuntimeError", exception_message: "Boom", backtrace: backtrace)
+      exception_event = described_class.new(name: "RuntimeError", error_message: "Boom", backtrace: backtrace)
       expect(exception_event.backtrace).to eq([{:file=>"malformed"}])
    end
   end

data/spec/timber/events/{http_server_request_spec.rb → http_request_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-describe Timber::Events::HTTPServerRequest, :rails_23 => true do
+describe Timber::Events::HTTPRequest, :rails_23 => true do
   describe ".initialize" do
     context "with a header filters" do
       around(:each) do |example|

data/spec/timber/integrations/action_dispatch/debug_exceptions_spec.rb

@@ -41,7 +41,7 @@ if defined?(::ActionDispatch)
         lines = clean_lines(io.string.split("\n"))
         expect(lines.length).to eq(3)
         expect(lines[2]).to start_with('RuntimeError (boom) @metadata {"level":"fatal",')
-        expect(lines[2]).to include("\"event\":{\"exception\":{\"name\":\"RuntimeError\",\"message\":\"boom\",\"backtrace\":[")
+        expect(lines[2]).to include("\"event\":{\"error\":{\"name\":\"RuntimeError\",\"message\":\"boom\",\"backtrace\":[")
       end
 
       # Remove blank lines since Rails does this to space out requests in the logs

data/spec/timber/logger_spec.rb

@@ -20,6 +20,15 @@ describe Timber::Logger, :rails_23 => true do
         expect(logger.formatter).to be_kind_of(Timber::Logger::MessageOnlyFormatter)
       end
     end
+
+    it "should use the Multi log device" do
+      io1 = StringIO.new
+      io2 = StringIO.new
+      logger = Timber::Logger.new(STDOUT, io1, io2)
+      logger.info("hello world")
+      expect(io1.string).to start_with("hello world @metadata {")
+      expect(io2.string).to start_with("hello world @metadata {")
+    end
   end
 
   describe "#add" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timber
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Timber Technologies, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-28 00:00:00.000000000 Z
+date: 2017-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -182,11 +182,9 @@ files:
 - lib/timber/events.rb
 - lib/timber/events/controller_call.rb
 - lib/timber/events/custom.rb
-- lib/timber/events/exception.rb
-- lib/timber/events/http_client_request.rb
-- lib/timber/events/http_client_response.rb
-- lib/timber/events/http_server_request.rb
-- lib/timber/events/http_server_response.rb
+- lib/timber/events/error.rb
+- lib/timber/events/http_request.rb
+- lib/timber/events/http_response.rb
 - lib/timber/events/sql_query.rb
 - lib/timber/events/template_render.rb
 - lib/timber/frameworks.rb
@@ -205,7 +203,7 @@ files:
 - lib/timber/integrations/active_record/log_subscriber.rb
 - lib/timber/integrations/active_record/log_subscriber/timber_log_subscriber.rb
 - lib/timber/integrations/rack.rb
-- lib/timber/integrations/rack/exception_event.rb
+- lib/timber/integrations/rack/error_event.rb
 - lib/timber/integrations/rack/http_context.rb
 - lib/timber/integrations/rack/http_events.rb
 - lib/timber/integrations/rack/middleware.rb
@@ -218,6 +216,7 @@ files:
 - lib/timber/log_devices/http.rb
 - lib/timber/log_devices/http/dropping_sized_queue.rb
 - lib/timber/log_devices/http/flushable_sized_queue.rb
+- lib/timber/log_devices/multi.rb
 - lib/timber/log_entry.rb
 - lib/timber/logger.rb
 - lib/timber/overrides.rb
@@ -261,8 +260,8 @@ files:
 - spec/timber/event_spec.rb
 - spec/timber/events/controller_call_spec.rb
 - spec/timber/events/custom_spec.rb
-- spec/timber/events/exception_spec.rb
-- spec/timber/events/http_server_request_spec.rb
+- spec/timber/events/error_spec.rb
+- spec/timber/events/http_request_spec.rb
 - spec/timber/events_spec.rb
 - spec/timber/integrations/action_controller/log_subscriber_spec.rb
 - spec/timber/integrations/action_dispatch/debug_exceptions_spec.rb
@@ -329,8 +328,8 @@ test_files:
 - spec/timber/event_spec.rb
 - spec/timber/events/controller_call_spec.rb
 - spec/timber/events/custom_spec.rb
-- spec/timber/events/exception_spec.rb
-- spec/timber/events/http_server_request_spec.rb
+- spec/timber/events/error_spec.rb
+- spec/timber/events/http_request_spec.rb
 - spec/timber/events_spec.rb
 - spec/timber/integrations/action_controller/log_subscriber_spec.rb
 - spec/timber/integrations/action_dispatch/debug_exceptions_spec.rb

data/lib/timber/events/http_client_request.rb

@@ -1,65 +0,0 @@
-require "timber/event"
-require "timber/util"
-
-module Timber
-  module Events
-    # The HTTP client request event tracks *outgoing* HTTP requests giving you structured insight
-    # into communication with external services.
-    #
-    # @note This event should be installed automatically through integrations,
-    #   such as the {Integrations::NetHTTP} integration.
-    class HTTPClientRequest < Timber::Event
-      attr_reader :body, :headers, :host, :method, :path, :port, :query_string, :request_id,
-        :scheme, :service_name
-
-      def initialize(attributes)
-        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
-        @host = attributes[:host] || raise(ArgumentError.new(":host is required"))
-        @method = Util::HTTPEvent.normalize_method(attributes[:method]) || raise(ArgumentError.new(":method is required"))
-        @path = attributes[:path]
-        @port = attributes[:port]
-        @query_string = Util::HTTPEvent.normalize_query_string(attributes[:query_string])
-        @request_id = attributes[:request_id]
-        @scheme = attributes[:scheme] || raise(ArgumentError.new(":scheme is required"))
-        @service_name = attributes[:service_name]
-
-        @body = Util::HTTPEvent.normalize_body(@headers["content-type"], attributes[:body])
-      end
-
-      def to_hash
-        {headers: headers, host: host, method: method, parsed_body_json: parsed_body_json,
-          path: path, port: port, query_string: query_string, request_id: request_id,
-          scheme: scheme, service_name: service_name}
-      end
-      alias to_h to_hash
-
-      # Builds a hash representation containing simple objects, suitable for serialization (JSON).
-      def as_json(_options = {})
-        {:http_client_request => to_hash}
-      end
-
-      def message
-        message = 'Outgoing HTTP request to '
-
-        if service_name
-          mesage << " #{service_name} [#{method}] #{full_path}"
-        else
-          message << " [#{method}] #{full_url}"
-        end
-      end
-
-      def status_description
-        Rack::Utils::HTTP_STATUS_CODES[status]
-      end
-
-      private
-        def full_path
-          Util::HTTPEvent.full_path(path, query_string)
-        end
-
-        def full_url
-          "#{scheme}#{host}#{full_path}"
-        end
-    end
-  end
-end

data/lib/timber/events/http_client_response.rb

@@ -1,51 +0,0 @@
-require "timber/event"
-require "timber/util"
-
-module Timber
-  module Events
-    # The HTTP client response event tracks responses for *outgoing* HTTP *requests*.
-    # This gives you structured insight into communication with external services.
-    #
-    # @note This event should be installed automatically through integrations,
-    #   such as the {Integrations::NetHTTP} integration.
-    class HTTPClientResponse < Timber::Event
-      attr_reader :body, :headers, :request_id, :service_name, :status, :time_ms
-
-      def initialize(attributes)
-        @headers = Util::HTTPEvent.normalize_headers(attributes[:headers])
-        @request_id = attributes[:request_id]
-        @service_name = attributes[:service_name]
-        @status = attributes[:status] || raise(ArgumentError.new(":status is required"))
-        @time_ms = attributes[:time_ms] || raise(ArgumentError.new(":time_ms is required"))
-        @time_ms = @time_ms.round(6)
-
-        @body = Util::HTTPEvent.normalize_body(@headers["content-type"], attributes[:body])
-      end
-
-      def to_hash
-        {body: body, headers: headers, request_id: request_id, service_name: service_name,
-          status: status, time_ms: time_ms}
-      end
-      alias to_h to_hash
-
-      # Builds a hash representation containing simple objects, suitable for serialization (JSON).
-      def as_json(_options = {})
-        {:http_client_response => to_hash}
-      end
-
-      def message
-        message = "Outgoing HTTP response"
-
-        if service_name
-          message << " from #{service_name}"
-        end
-
-        message << " #{status_description} in #{time_ms}ms"
-      end
-
-      def status_description
-        Rack::Utils::HTTP_STATUS_CODES[status]
-      end
-    end
-  end
-end