RubyGems - timber - Versions diffs - 1.1.7 → 1.1.8 - Mend

timber 1.1.7 → 1.1.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml +4 -4
data/README.md +140 -142
data/lib/timber.rb +2 -0
data/lib/timber/logger.rb +22 -1
data/lib/timber/overrides/rails_stdout_logging.rb +21 -0
data/lib/timber/version.rb +1 -1
data/spec/timber/logger_spec.rb +15 -0
metadata +3 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eedbdde12666a1140ddf56d8d94a69e21fdd447a
-  data.tar.gz: 687c97f7258d47d0d40fae21030b5efca5f47c79
+  metadata.gz: 3c9b324e70feb9ff1373222ba8a5f713a7c3137a
+  data.tar.gz: 73ec3459c15d1a9438f762c9aec975eefd1e2852
 SHA512:
-  metadata.gz: b000f04c0d0d15e9500210e886500af6bebe1dfe8fb72147b7d0b15b2858e76ccebcdb851b139c64fccd001e55764b59eca299d98ff31849899ba304c39e12c6
-  data.tar.gz: bcb842aec9aca3249b0ff4c572686dd39864dd79711ad36bc0acac60d6de67e989912a6bf75b318e23078620601e3578a23c2c33db52528334bd5cc231133623
+  metadata.gz: ac167d0a6d8ae1f7968d3df367203d75df9405f26dd89d6d4bb6a0641182f45d6290c771f187099f6858633f593bac5d49da086fc1b35b4028745c377385ae98
+  data.tar.gz: 9b6d80aae0f5f44c821ea73f00ff9418e2656b52d007840c292f189182b4480e6b9907beae8bf365ace3d255f68494ac36668a84a9d40ab34f17ca51fa2ed302

data/README.md CHANGED Viewed

@@ -1,7 +1,7 @@
 # 🌲 Timber - Master your Ruby apps with structured logging
 <p align="center" style="background: #140f2a;">
-<a href="http://github.com/timberio/timber-ruby"><img src="http://files.timber.io/images/ruby-library-readme-header.gif" height="469" /></a>
+<a href="http://files.timber.io/images/readme-interface.gif"><img src="http://files.timber.io/images/readme-interface.gif" width="100%" /></a>
 </p>
 [![ISC License](https://img.shields.io/badge/license-ISC-ff69b4.svg)](LICENSE.md)
@@ -10,108 +10,125 @@
 [![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)
+Still logging raw text? Timber is a complete *structured* logging solution that you can setup in
+minutes. It solves logging so you don't have to!
----
+To learn more, checkout out [timber.io](https://timber.io).
-👉 **Timber is in beta testing, if interested in joining, please email us at
-[beta@timber.io](mailto:beta@timber.io)**
----
+## Installation
-Still logging raw text? Timber is a complete *structured* logging solution that you can setup in
-minutes. It goes beyond traditional log management by focusing on data quality and modern
-developer standards.
+1. *Add* the `timber` gem in `Gemfile`:
-High quality logs, [a modern UX-first interface](https://timber.io), simple setup,
-zero-maintenance, 6-month retention, and sane prices are just a few of the benefits Timber
-offers.
+  ```ruby
+  # Gemfile
-To learn more, checkout out [timber.io](https://timber.io) or the
-["why we built Timber"](http://moss-ibex2.cloudvent.net/blog/why-were-building-timber/)
-blog post.
+  gem 'timber'
+  ```
+2. *Install* the `Timber::Logger` in `config/environments/production.rb`:
-## Overview
+  ```ruby
+  # config/environments/production.rb
-<details><summary><strong>What are the benefits of using Timber?</strong></summary><p>
+  # config.log_formatter = ::Logger::Formatter.new # <--------------------------- REMOVE ME
+  # config.logger = ActiveSupport::TaggedLogging.new(logger) # <----------------- REMOVE ME
-1. **Data quality.** The usefulness of your logs starts here. This is why we ship libraries that
-   structure logs from *within* your application; a fundamental difference from parsing. Not only
-   is it much more stable, but we can include data you couldn't obtain otherwise.
-2. **Human readability.** Structuring your logs doesn't mean they have to be unreadable. Timber
-   *augments* your logs with structured data. Meaning we do not alter the original log message,
-   we simply attach metadata to it. And our console is specifically designed to give you access
-   to this data, without compromising readability. 😮
-3. **Reliable downstream consumption.** All log events adhere to a
-   [normalized, shared, schema](https://github.com/timberio/log-event-json-schema) that follows
-   [semantic versioning](http://semver.org/) and goes through a [standard release process](https://github.com/timberio/log-event-json-schema/releases).
-   This means you can *rely* on the structure of your logs and interact consistently with them
-   across apps of any language: queries, graphs, alerts, and other downstream consumers.
-4. **Zero risk of code debt or lock-in.** Logging is a standard that has been around since the dawn
-   of computers. It's built into every language, framework, and library. Timber adheres strictly
-   to the default `Logger` interface. There are no special APIs, and no need to pepper your app
-   with Timber specific code. It's just better logging. If you choose to stop using Timber, you
-   can do so without consequence.
-5. **Long term retention.** Timber is designed on modern big-data principles. As a result, we can
-   offer 6+ months of retention at prices cheaper than alternatives offering <1 month.
-   This allows you to unlock your logs for purposes beyond debugging.
+  config.logger = ActiveSupport::TaggedLogging.new(Timber::Logger.new(STDOUT)) # <-- ADD ME
+  ```
+---
+<details><summary><strong>Prefer to see an example pull request?</strong></summary><p>
+Checkout our the [Timber install example pull request](https://github.com/timberio/ruby-rails-example-app/pull/1/files)
 ---
 </p></details>
-<details><summary><strong>What specifically does the Timber library do?</strong></summary><p>
+<details><summary><strong>Not using Rails?</strong></summary><p>
-1. Captures and structures your framework and 3rd party logs. (see next question)
-2. Adds useful context to every log line. (see next question)
-3. Allows you to easily add tags and timings to log. (see [Usage](#usage))
-4. Provides a framework for logging custom structured events. (see [Usage](#usage))
-5. Offers transport strategies to [send your logs](#send-your-logs) to the Timber service.
+No problem! You can easily install Timber following these steps:
+1. *Insert* the Timber probes:
+  This should be executed *immediately after* you have required your dependencies.
+  ```ruby
+  Timber::Probes.insert!
+  ```
+2. *Add* the Rack middlewares:
+  This should be included where you build your `Rack` application. Usually `config.ru`:
+  ```ruby
+  # Most likely config.ru
+  Timber::RackMiddlewares.middlewares.each do |m|
+    use m
+  end
+  ```
+2. *Instantiate* the Timber logger:
+  This should be *globally* available to your application:
+  ```ruby
+  logger = Timber::Logger.new(STDOUT)
+  ```
 ---
 </p></details>
-<details><summary><strong>What events does Timber capture & structure for me?</strong></summary><p>
-Out of the box you get everything in the [`Timber::Events`](lib/timber/events) namespace:
-1. [Controller Call Event](lib/timber/events/controller_call.rb)
-2. [Exception Event](lib/timber/events/exception.rb)
-3. [HTTP Client Request Event (net/http outgoing)](lib/timber/events/http_client_request.rb)
-4. [HTTP Client Response Event (resposne from net/http outgoing)](lib/timber/events/http_client_response.rb)
-5. [HTTP Server Request Event (incoming client request)](lib/timber/events/http_server_request.rb)
-6. [HTTP Server Response Event (response to incoming client request)](lib/timber/events/http_server_response.rb)
-7. [SQL Query Event](lib/timber/events/sql_query.rb)
-8. [Template Render Event](lib/timber/events/template_render.rb)
-9. ...more coming soon, [file an issue](https://github.com/timberio/timber-ruby/issues) to request.
-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:
-1. [HTTP Context](lib/timber/contexts/http.rb)
-2. [Organization Context](lib/timber/contexts/organization.rb)
-3. [Process Context](lib/timber/contexts/process.rb)
-4. [Server Context](lib/timber/contexts/server.rb)
-5. [Runtime Context](lib/timber/contexts/runtime.rb)
-5. [User Context](lib/timber/contexts/user.rb)
-6. ...more coming soon, [file an issue](https://github.com/timberio/timber-ruby/issues) to request.
+## Send your logs (choose one)
+<details><summary><strong>Heroku (log drains)</strong></summary><p>
+The recommended strategy for Heroku is to setup a
+[log drain](https://devcenter.heroku.com/articles/log-drains). To get your Timber log drain URL:
+👉 **[Add your app to Timber](https://app.timber.io)**
 ---
 </p></details>
-<details><summary><strong>What about my current log statements?</strong></summary><p>
+<details><summary><strong>All other platforms (Network / HTTP)</strong></summary><p>
-They'll continue to work as expected. Timber adheres strictly to the default `::Logger` interface
-and will never deviate in *any* way.
+1. *Specify* the Timber Network logger backend in `config/environments/production.rb`:
-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).
+  Replace any existing `config.logger =` calls with:
+  ```ruby
+  # config/environments/production.rb (or staging, etc)
+  network_log_device = Timber::LogDevices::Network.new(ENV['TIMBER_LOGS_KEY'])
+  config.logger = Timber::Logger.new(network_log_device) # <-- Use network_log_device instead of STDOUT
+  ```
+2. Obtain your Timber API :key: by **[adding your app in Timber](https://app.timber.io)**.
+3. Assign your API key to the `TIMBER_LOGS_KEY` environment variable.
 </p></details>
+<details><summary><strong>Advanced setup (syslog, file tailing agent, etc)</strong></summary><p>
+Checkout our [docs](https://timber.io/docs) for a comprehensive list of install instructions.
+</p></details>
 ## Usage
 <details><summary><strong>Basic logging</strong></summary><p>
@@ -287,103 +304,84 @@ value.
 </p></details>
+## Jibber-Jabber
-## Installation
-```ruby
-# Gemfile
-gem 'timber'
-```
-## Setup
-<details><summary><strong>Rails (all versions, including edge)</strong></summary><p>
-👉 **Prefer examples?** Checkout our the [Timber install example pull request](https://github.com/timberio/ruby-rails-example-app/pull/1/files)
----
-*Replace* any existing `config.logger=` calls in `config/environments/production.rb` with:
-```ruby
-# config/environments/production.rb
+<details><summary><strong>What specifically does the Timber library do?</strong></summary><p>
-config.logger = ActiveSupport::TaggedLogging.new(Timber::Logger.new(STDOUT))
-```
+1. Captures and structures your framework and 3rd party logs. (see next question)
+2. Adds useful context to every log line. (see next question)
+3. Allows you to easily add tags and timings to log. (see [Usage](#usage))
+4. Provides a framework for logging custom structured events. (see [Usage](#usage))
+5. Offers transport strategies to [send your logs](#send-your-logs) to the Timber service.
 ---
 </p></details>
-<details><summary><strong>Other</strong></summary><p>
-1. *Insert* the Timber probes:
-  This should be executed *immediately after* you have required your dependencies.
-  ```ruby
-  Timber::Probes.insert!
-  ```
-2. *Add* the Rack middlewares:
-  This should be included where you build your `Rack` application. Usually `config.ru`:
-  ```ruby
-  # Most likely config.ru
-  Timber::RackMiddlewares.middlewares.each do |m|
-    use m
-  end
-  ```
-2. *Instantiate* the Timber logger:
+<details><summary><strong>What are the benefits of using Timber?</strong></summary><p>
-  This should be *globally* available to your application:
+1. **Data quality.** The usefulness of your logs starts here. This is why we ship libraries that
+   structure logs from *within* your application; a fundamental difference from parsing. Not only
+   is it much more stable, but we can include data you couldn't obtain otherwise.
+2. **Human readability.** Structuring your logs doesn't mean they have to be unreadable. Timber
+   *augments* your logs with structured data. Meaning we do not alter the original log message,
+   we simply attach metadata to it. And our console is specifically designed to give you access
+   to this data, without compromising readability. 😮
+3. **Reliable downstream consumption.** All log events adhere to a
+   [normalized, shared, schema](https://github.com/timberio/log-event-json-schema) that follows
+   [semantic versioning](http://semver.org/) and goes through a [standard release process](https://github.com/timberio/log-event-json-schema/releases).
+   This means you can *rely* on the structure of your logs and interact consistently with them
+   across apps of any language: queries, graphs, alerts, and other downstream consumers.
+4. **Zero risk of code debt or lock-in.** Logging is a standard that has been around since the dawn
+   of computers. It's built into every language, framework, and library. Timber adheres strictly
+   to the default `Logger` interface. There are no special APIs, and no need to pepper your app
+   with Timber specific code. It's just better logging. If you choose to stop using Timber, you
+   can do so without consequence.
+5. **Long term retention.** Timber is designed on modern big-data principles. As a result, we can
+   offer 6+ months of retention at prices cheaper than alternatives offering <1 month.
+   This allows you to unlock your logs for purposes beyond debugging.
-  ```ruby
-  logger = Timber::Logger.new(STDOUT)
-  ```
+---
 </p></details>
+<details><summary><strong>What events does Timber capture & structure for me?</strong></summary><p>
-## Send your logs
+Out of the box you get everything in the [`Timber::Events`](lib/timber/events) namespace:
-<details><summary><strong>Heroku (log drains)</strong></summary><p>
+1. [Controller Call Event](lib/timber/events/controller_call.rb)
+2. [Exception Event](lib/timber/events/exception.rb)
+3. [HTTP Client Request Event (net/http outgoing)](lib/timber/events/http_client_request.rb)
+4. [HTTP Client Response Event (resposne from net/http outgoing)](lib/timber/events/http_client_response.rb)
+5. [HTTP Server Request Event (incoming client request)](lib/timber/events/http_server_request.rb)
+6. [HTTP Server Response Event (response to incoming client request)](lib/timber/events/http_server_response.rb)
+7. [SQL Query Event](lib/timber/events/sql_query.rb)
+8. [Template Render Event](lib/timber/events/template_render.rb)
+9. ...more coming soon, [file an issue](https://github.com/timberio/timber-ruby/issues) to request.
-The recommended strategy for Heroku is to setup a
-[log drain](https://devcenter.heroku.com/articles/log-drains). To get your Timber log drain URL:
+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:
-👉 **[Add your app to Timber](https://app.timber.io)**
+1. [HTTP Context](lib/timber/contexts/http.rb)
+2. [Organization Context](lib/timber/contexts/organization.rb)
+3. [Process Context](lib/timber/contexts/process.rb)
+4. [Server Context](lib/timber/contexts/server.rb)
+5. [Runtime Context](lib/timber/contexts/runtime.rb)
+5. [User Context](lib/timber/contexts/user.rb)
+6. ...more coming soon, [file an issue](https://github.com/timberio/timber-ruby/issues) to request.
 ---
 </p></details>
-<details><summary><strong>All other platforms (Network / HTTP)</strong></summary><p>
-1. *Specify* the Timber Network logger backend in `config/environments/production.rb`:
-  Replace any existing `config.logger =` calls with:
-  ```ruby
-  # config/environments/production.rb (or staging, etc)
-  network_log_device = Timber::LogDevices::Network.new(ENV['TIMBER_LOGS_KEY'])
-  config.logger = Timber::Logger.new(network_log_device) # <-- Use network_log_device instead of STDOUT
-  ```
-2. Obtain your Timber API :key: by **[adding your app in Timber](https://app.timber.io)**.
-3. Assign your API key to the `TIMBER_LOGS_KEY` environment variable.
-</p></details>
+<details><summary><strong>What about my current log statements?</strong></summary><p>
-<details><summary><strong>Advanced setup (syslog, file tailing agent, etc)</strong></summary><p>
+They'll continue to work as expected. Timber adheres strictly to the default `::Logger` interface
+and will never deviate in *any* way.
-Checkout our [docs](https://timber.io/docs) for a comprehensive list of install instructions.
+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).
 </p></details>

data/lib/timber.rb CHANGED Viewed

@@ -1,6 +1,8 @@
 # core classes
 require "json" # brings to_json to the core classes
+require "timber/overrides/rails_stdout_logging"
 # Base (must come first, order matters)
 require "timber/config"
 require "timber/context"

data/lib/timber/logger.rb CHANGED Viewed

@@ -60,6 +60,7 @@ module Timber
   #   Logger.info PymentRejectedEvent.new("abcd1234", 100)
   #
   class Logger < ::Logger
     # @private
     class Formatter
       # Formatters get the formatted level from the logger.
@@ -161,11 +162,19 @@ module Timber
     #   logger.formatter = Timber::Logger::JSONFormatter.new
     def initialize(*args)
       super(*args)
+      # Ensure we sync STDOUT to avoid buffering
+      if args.size == 1 and args.first.respond_to?(:"sync=")
+        args.first.sync = true
+      end
       if args.size == 1 and args.first.is_a?(LogDevices::HTTP)
         self.formatter = PassThroughFormatter.new
       else
         self.formatter = HybridFormatter.new
       end
+      self.level = environment_level
     end
     def formatter=(value)
@@ -174,7 +183,13 @@ module Timber
           "Timber::LogDevices::HTTP log device. The PassThroughFormatter must be used for proper " +
           "delivery.")
       end
-      super
+      if !value.is_a?(Timber::Logger::Formatter)
+        # silently discard this value since rails calls this during initialization :/
+        nil
+      else
+        super
+      end
     end
     # Backwards compatibility with older ActiveSupport::Logger versions
@@ -185,5 +200,11 @@ module Timber
         end                                      # end
       EOT
     end
+    private
+      def environment_level
+        level = ([ENV['LOG_LEVEL'].to_s.upcase, "DEBUG"] & %w[DEBUG INFO WARN ERROR FATAL UNKNOWN]).compact.first
+        self.class.const_get(level)
+      end
   end
 end

data/lib/timber/overrides/rails_stdout_logging.rb ADDED Viewed

@@ -0,0 +1,21 @@
+# See https://github.com/heroku/rails_stdout_logging
+# I have no idea why this library was created, but most Heroku / Rails apps use it.
+# This library completely obliterates any logger configuration you set.
+# So this patch fixes that.
+begin
+  require "rails_stdout_logging"
+  module RailsStdoutLogging
+    class Rails2 < Rails
+      def self.set_logger
+      end
+    end
+    class Rails3 < Rails
+      def self.set_logger(config)
+      end
+    end
+  end
+rescue Exception
+end

data/lib/timber/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Timber
-  VERSION = "1.1.7"
+  VERSION = "1.1.8"
 end

data/spec/timber/logger_spec.rb CHANGED Viewed

@@ -117,4 +117,19 @@ describe Timber::Logger, :rails_23 => true do
       end
     end
   end
+  describe "#formatter=" do
+    let(:io) { StringIO.new }
+    let(:logger) { Timber::Logger.new(io) }
+    it "should not allow non Timber::Logger::Formatter formatters" do
+      logger.formatter = ::Logger::Formatter.new
+      expect(logger.formatter).to be_kind_of(::Timber::Logger::HybridFormatter)
+    end
+    it "should allow Timber::Logger::Formatter formatters" do
+      logger.formatter = ::Timber::Logger::JSONFormatter.new
+      expect(logger.formatter).to be_kind_of(::Timber::Logger::JSONFormatter)
+    end
+  end
 end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: timber
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.1.8
 platform: ruby
 authors:
 - Timber Technologies, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -79,6 +79,7 @@ files:
 - lib/timber/log_devices/http.rb
 - lib/timber/log_entry.rb
 - lib/timber/logger.rb
+- lib/timber/overrides/rails_stdout_logging.rb
 - lib/timber/probe.rb
 - lib/timber/probes.rb
 - lib/timber/probes/action_controller_log_subscriber.rb