tty-logger 0.1.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdcb294c5428dc04d50845cb289e13bd679d78343e3557f7de4423798475c0af
-  data.tar.gz: 600425284bc08e004523363bdc78ee4a4b8a37b05f0930a2eef4d0b013eb7b38
+  metadata.gz: 708549fdd3524759b7404ed40af85915383fbd0be763133ce06b569931dd776b
+  data.tar.gz: 8279b0f105fb3fe7c04e82a129a898f831c48b1b9141d52532f44270ff431d0e
 SHA512:
-  metadata.gz: 465c8e6fabae9d94f2b884715350ad3bbc1182f132d8e8b504d6b4b62a84669765d05ae60815bc79ffc83749ed43ab67a099f820708f1e1e3c3526b1de470258
-  data.tar.gz: d583794d9e15390b86138778cf5371a7401f1f1436af4c2fd15162dee2fdef54d9de663a96396915f5fd0c0139b1b42b8b20eda461f013903dcd6c831be6670a
+  metadata.gz: 2198bb08a4e783e13910e44934c4d4f7a4eb27c5f724f6d0911acb31f54bac546e239ed04565893ca2993a516924ebba2f6d3a2d00b8ad57e35c4c44db69ecd2
+  data.tar.gz: c89656676101aae012ad6d3cc236deb11fc80dc7e5026be7a64c77bb25917d40425085fb3a906b0d61436c69ef4b3e67c7fc4ad178a60718bdc347918e5327ba

data/CHANGELOG.md

@@ -1,7 +1,69 @@
 # Change log
 
+## [v0.6.0] - 2020-12-05
+
+### Added
+* Add :enable_color option to control coloring in the console handler
+
+### Changed
+* Change #add_handler to accept handler configuration options as an extra parameter
+
+### Fixed
+* Fix removing handlers by name or type
+
+## [v0.5.0] - 2020-09-27
+
+### Added
+* Add :message_format option to customize how messages are displayed in the console
+  by Josh Greenwood (@JoshTGreenwood)
+
+### Fixed
+* Fix to select event name from valid log types or current level
+  by Ryan Schlesinger (@ryansch)
+* Fix duplicate filters attribute definition in TTY::Logger::Config
+
+## [v0.4.0] - 2020-07-29
+
+### Added
+* Allow editing logger configuration at runtime ([#10](https://github.com/piotrmurach/tty-logger/pull/10))
+* Support for the `<<` streaming operator ([#9](https://github.com/piotrmurach/tty-logger/pull/9)))
+
+### Changed
+* Change gemspec to update pastel version and restrict only to minor version
+
+### Fixed
+* Fix to filter sensitive information from exceptions
+
+## [v0.3.0] - 2020-01-01
+
+### Added
+* Add ability to filter sensitive information out of structured data
+
+### Changed
+* Remove the test and task files from the gemspec
+
+### Fixed
+* Fix console handler highlighting of nested hash keys
+
+## [v0.2.0] - 2019-09-30
+
+### Added
+* Add ability to add structured data inside logging block
+* Add ability to filter sensitive data
+* Add ability to define custom log types
+* Add ability to temporarily log at different level
+* Add performance tests
+
+### Changed
+* Change to dynamically define log types
+
 ## [v0.1.0] - 2019-07-21
 
 * Initial implementation and release
 
+[v0.6.0]: https://github.com/piotrmurach/tty-logger/compare/v0.5.0..v0.6.0
+[v0.5.0]: https://github.com/piotrmurach/tty-logger/compare/v0.4.0..v0.5.0
+[v0.4.0]: https://github.com/piotrmurach/tty-logger/compare/v0.3.0..v0.4.0
+[v0.3.0]: https://github.com/piotrmurach/tty-logger/compare/v0.2.0..v0.3.0
+[v0.2.0]: https://github.com/piotrmurach/tty-logger/compare/v0.1.0..v0.2.0
 [v0.1.0]: https://github.com/piotrmurach/tty-logger/compare/v0.1.0

data/README.md

@@ -1,11 +1,11 @@
 <div align="center">
-  <a href="https://piotrmurach.github.io/tty" target="_blank"><img width="130" src="https://cdn.rawgit.com/piotrmurach/tty/master/images/tty.png" alt="tty logo" /></a>
+  <a href="https://ttytoolkit.org" target="_blank"><img width="130" src="https://github.com/piotrmurach/tty/raw/master/images/tty.png" alt="tty logo" /></a>
 </div>
 
-# TTY::Logger
+# TTY::Logger [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
 
 [![Gem Version](https://badge.fury.io/rb/tty-logger.svg)][gem]
-[![Build Status](https://secure.travis-ci.org/piotrmurach/tty-logger.svg?branch=master)][travis]
+[![Actions CI](https://github.com/piotrmurach/tty-logger/workflows/CI/badge.svg?branch=master)][gh_actions_ci]
 [![Build status](https://ci.appveyor.com/api/projects/status/vtrkdk0naknnxoog?svg=true)][appveyor]
 [![Code Climate](https://codeclimate.com/github/piotrmurach/tty-logger/badges/gpa.svg)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/github/piotrmurach/tty-logger/badge.svg)][coverage]
@@ -13,7 +13,7 @@
 
 [gitter]: https://gitter.im/piotrmurach/tty
 [gem]: http://badge.fury.io/rb/tty-logger
-[travis]: http://travis-ci.org/piotrmurach/tty-logger
+[gh_actions_ci]: https://github.com/piotrmurach/tty-logger/actions?query=workflow%3ACI
 [appveyor]: https://ci.appveyor.com/project/piotrmurach/tty-logger
 [codeclimate]: https://codeclimate.com/github/piotrmurach/tty-logger
 [coverage]: https://coveralls.io/github/piotrmurach/tty-logger
@@ -30,6 +30,8 @@
 * Intuitive console output for an increased readability
 * Ability to stream data to any IO object
 * Supports structured data logging
+* Filters sensitive data
+* Allows to define custom log types
 * Formats and truncates messages to avoid clogging logging output
 * Customizable styling of labels and symbols for console output
 * Includes metadata information: time, location, scope
@@ -40,7 +42,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'tty-logger'
+gem "tty-logger"
 ```
 
 And then execute:
@@ -58,17 +60,23 @@ Or install it yourself as:
 * [2. Synopsis](#2-synopsis)
   * [2.1 Logging](#21-logging)
     * [2.1.1 Exceptions](#211-exceptions)
+    * [2.1.2 Types](#212-types)
   * [2.2 Levels](#22-levels)
+    * [2.2.1 Scoped Level](#22-scoped-level)
   * [2.3 Structured Data](#23-structured-data)
   * [2.4 Configuration](#24-configuration)
     * [2.4.1 Metadata](#241-metadata)
-  * [2.5 Handlers](#25-handlers)
-    * [2.5.1 Console Handler](#251-console-handler)
-    * [2.5.2 Stream Handler](#252-stream-handler)
-    * [2.5.3 Custom Handler](#253-custom-handler)
-    * [2.5.4 Multiple Handlers](#254-multiple-handlers)
-  * [2.6 Formatters](#26-formatters)
-  * [2.7 Output streams](#27-output-streams)
+    * [2.4.2 Filters](#242-filters)
+  * [2.5 Cloning](#25-cloning)
+  * [2.6 Handlers](#26-handlers)
+    * [2.6.1 Console Handler](#261-console-handler)
+    * [2.6.2 Stream Handler](#262-stream-handler)
+    * [2.6.3 Custom Handler](#263-custom-handler)
+    * [2.6.4 Multiple Handlers](#264-multiple-handlers)
+  * [2.7 Formatters](#27-formatters)
+  * [2.8 Output streams](#28-output-streams)
+* [3. Community Extensions](#3-community-extensions)
+  * [3.1 Sentry Handler](#31-sentry-handler)
 
 ## 1. Usage
 
@@ -78,7 +86,7 @@ Create logger:
 logger = TTY::Logger.new
 ```
 
-And log information using any of the logger [types](#21-types):
+And log information using any of the logger [built-in types](#212-types):
 
 ```ruby
 logger.info "Deployed successfully"
@@ -89,7 +97,7 @@ logger.info { "Dynamically generated info" }
 Include structured data:
 
 ```ruby
-logger.info "Deployed successfully", myapp: "myapp", env: "prod"
+logger.success "Deployed successfully", myapp: "myapp", env: "prod"
 # =>
 # ✔ success Deployed successfully     app=myapp env=prod
 ```
@@ -105,7 +113,7 @@ logger.info "Deployed successfully", myapp: "myapp", env: "prod"
 # [2019-07-17] [23:21:55.287] › ℹ info    Info about the deploy     app=myapp env=prod
 ```
 
-Or change structured data [formatting](#26-formatters) display to `JSON`:
+Or change structured data [formatting](#27-formatters) display to `JSON`:
 
 ```ruby
 logger = TTY::Logger.new do |config|
@@ -148,13 +156,23 @@ logger.success "Deployed", "successfully"
 
 You can delay message evaluation by passing it inside a block:
 
+```ruby
+logger.success { "Dynamically generated info" }
+# =>
+# ✔ success Dynamically generated info
 ```
-logger.info { "Dynamically generated info" }
+
+Similar to regular logging, you cal split your message into chunks inside a block:
+
+```ruby
+logger.success { ["Dynamically", "generated", "info"] }
 # =>
-# ✔ success Deployed successfully
+# ✔ success Dynamically generated info
 ```
 
-### 2.1.1 Exceptions
+The above comes handy when paired with [structured data](#23-structured-data).
+
+#### 2.1.1 Exceptions
 
 You can also report on exceptions.
 
@@ -164,7 +182,7 @@ For example, let's say you caught an exception about incorrect data format and u
 begin
   raise ArgumentError, "Wrong data"
 rescue => ex
-  logger.fatal("Error:", error)
+  logger.fatal("Error:", ex)
 end
 ```
 
@@ -178,6 +196,51 @@ This will result in a message followed by a full backtrace:
 #    rspec-core-3.8.2/lib/rspec/core/example.rb:257:in `block in run'
 ```
 
+#### 2.1.2 Types
+
+You can define custom log types via the `types` configuration option:
+
+For example, if you want to add `thanks` and `done` log types, you need to provide their names along with logging levels. You can further customise the `:console` output with your desired styling:
+
+```ruby
+logger = TTY::Logger.new do |config|
+  config.types = {
+    thanks: {level: :info},
+    done: {level: :info}
+  }
+  config.handlers = [
+    [:console, {
+      styles: {
+        thanks: {
+          symbol: "❤️ ",
+          label: "thanks",
+          color: :magenta,
+          levelpad: 0
+        },
+        done: {
+          symbol: "!!",
+          label: "done",
+          color: :green,
+          levelpad: 2
+        }
+      }
+    }]
+  ]
+end
+```
+
+Once defined, you can call new log types:
+
+```ruby
+logger.thanks("Great work!")
+logger.done("Work done!")
+# =>
+# ❤️  thanks Great work!
+# !! done   Work done!
+```
+
+![](assets/tty-logger-custom-log-types.png)
+
 ### 2.2 Levels
 
 The supported levels, ordered by precedence, are:
@@ -192,17 +255,17 @@ So the order is: `:debug` < `:info` < `:warn` < `:error` < `:fatal`
 
 For example, `:info` takes precedence over `:debug`. If your log level is set to `:info`, `:info`, `:warn`, `:error` and `:fatal` will be printed to the console. If your log level is set to `:warn`, only `:warn`, `:error` and `:fatal` will be printed.
 
-You can set level using the `level` configuration option. The value can be a symbol, a string or level constant. For example, `:info`, `INFO` or `TTY::Logger::INFO_LEVEL` will quality as valid level value.
+You can set level using the `level` configuration option. The value can be a symbol, a string or level constant. For example, `:info`, `INFO` or `TTY::Logger::INFO_LEVEL` will qualify as valid level value.
 
 ```ruby
 TTY::Logger.new do |config|
-  config.level = :info # or "INFO" / TTY::Logger::INFO_LEVEL
+  config.level = :info # or "INFO" or TTY::Logger::INFO_LEVEL
 end
 ```
 
 Or you can specific level for each log events handler.
 
-For example, to log messages above info level to a stream and only error level events to the console do:
+For example, to log messages above `:info` level to a stream and only `:error` level events to the console do:
 
 ```ruby
 logger = TTY::Logger.new do |config|
@@ -213,7 +276,34 @@ logger = TTY::Logger.new do |config|
 end
 ```
 
-You can also change the [output streams](#27-output-streams) for each handler.
+You can also change the [output streams](#28-output-streams) for each handler.
+
+#### 2.2.1 Scoped Level
+
+You can temporarily change level, raise it or lower it by using the `log_at` call. By default messages are logged at `:info` level, but you can change this for the duration of a block:
+
+```ruby
+logger = TTY::Logger.new
+
+logger.info("not logged")
+
+logger.log_at :debug do
+  logger.debug("logged")
+end
+# =>
+# • debug   logged
+```
+
+Or elevate a level to an error with a constant `ERROR_LEVEL`:
+
+```ruby
+logger.log_at TTY::Logger::ERROR_LEVEL do
+  logger.debug("not logged")
+  logger.error("logged")
+end
+# =>
+# ⨯ error   logged
+```
 
 ### 2.3 Structured data
 
@@ -236,16 +326,28 @@ logger.wait "Ready to deploy", app: "myapp", env: "prod"
 # … waiting Ready to deploy           app=myapp env=prod
 ```
 
+You can delay data evaluation until it's evaluated by passing it inside a block:
+
+```ruby
+logger.wait { ["Ready to deploy", {app: "myapp", env: "prod"}] }
+# =>
+# … waiting Ready to deploy           app=myapp env=prod
+```
+
 ### 2.4 Configuration
 
-All the configuration options can be changed globally via `configure` or per logger instance via object initialization.
+All the configuration options can be changed globally via `configure` or per logger instance.
 
-* `:formatter` - the formatter used to display structured data. Defaults to `:text`. see [Formatters](#26-formatters) for more details.
-* `:handlers` - the handlers used to log messages. Defaults to `[:console]`. See [Handlers](#25-handlers) for more details.
+* `:filters` - the storage of placeholders to filter sensitive data out from the logs. Defaults to `{}`.
+* `:formatter` - the formatter used to display structured data. Defaults to `:text`. See [Formatters](#27-formatters) for more details.
+* `:handlers` - the handlers used to log messages. Defaults to `[:console]`. See [Handlers](#26-handlers) for more details.
 * `:level` - the logging level. Any message logged below this level will be simply ignored. Each handler may have it's own default level. Defaults to `:info`
 * `:max_bytes` - the maximum message size to be logged in bytes. Defaults to `8192` bytes. The truncated message will have `...` at the end.
 * `:max_depth` - the maximum depth for nested structured data. Defaults to `3`.
 * `:metadata` - the meta info to display before the message, can be `:pid`, `:date`, `:time` or `:file`. Defaults to empty array `[]`, no metadata. Setting this to `:all` will print all the metadata.
+* `:types` - the new custom log types. Defaults to `{}`.
+* `:date_format` - uses `strftime` format to display dates. Defaults to `"%F"`.
+* `:time_format` - uses `strftime` format to display times. Defaults to `"%T.%3N"`.
 
 For example, to configure `:max_bytes`, `:level` and `:metadata` for all logger instances do:
 
@@ -266,6 +368,14 @@ logger = TTY::Logger.new do |config|
 end
 ```
 
+You can also change the logger's configuration at runtime:
+
+```ruby
+logger.configure do |config|
+  config.level = :debug
+end
+```
+
 ### 2.4.1 Metadata
 
 The `:metdata` configuration option can include the following symbols:
@@ -275,7 +385,130 @@ The `:metdata` configuration option can include the following symbols:
 * `:time` - the log event time
 * `:file` - the file with a line number the log event is triggered from
 
-### 2.5 Handlers
+### 2.4.2 Filters
+
+You can filter sensitive data out of log output with `filters` configuration option. The `filters` can be further configured to remove info from log message with `message` or structured data with `data`. Both methods, as a value accept a list of sensitive items to search for.
+
+If you want to filter sensitive information from log messages use `message`:
+
+```ruby
+logger = TTY::Logger.new(output: output) do |config|
+  config.filters.message = %w[secret password]
+end
+```
+
+Which by default will replace each matching string with `[FILTERED]` placeholder:
+
+```ruby
+logger.info("Super secret info with password")
+# =>
+# ℹ info    Super [FILTERED] info with [FILTERED]
+```
+
+You can also replace each data item with a custom placeholder. To do so use a `:mask` keyword with a replacement placeholder.
+
+For example, to replace "secret" content with placeholder `"<SECRET>"` do:
+
+```ruby
+logger = TTY::Logger.new do |config|
+  config.filters.message = %w[secret]
+  config.filters.mask = "<SECRET>"
+end
+```
+
+When logged, it will produce:
+
+```ruby
+logger.info("Super secret info")
+# =>
+# ℹ info    Super <SECRET> info
+```
+
+To filter out sensitive information out of structured data use `data` method. By default any value matching a parameter name will be filtered regardless of the level of nesting. If you wish to filter only a specific deeply nested key use a dot notation like `params.card.password` to only filter `{params: {card: {password: "Secret123"}}}`.
+
+For example to filter out a `:password` from data do:
+
+```ruby
+logger = TTY::Logger.new do |config|
+  config.filters.data = %i[password]
+end
+```
+
+This will filter out any key matching password:
+
+```ruby
+logger.info("Secret info", password: "Secret123", email: "")
+# =>
+# ℹ info    Secret info     password="[FILTERED]" email="secret@example.com"
+```
+
+But also any nested data item:
+
+```ruby
+logger.info("Secret info", params: {password: "Secret123", email: ""})
+# =>
+# ℹ info    Secret info     params={password="[FILTERED]" email="secret@example.com"}
+```
+
+You're not limited to using only direct string comparison. You can also match based on regular expressions. For example, to match keys starting with `ba` we can add a following filter:
+
+```ruby
+logger = TTY::Logger.new do |config|
+  config.filters.data = [/ba/]
+end
+```
+
+Then appropriate values will be masked:
+
+```ruby
+logger.info("Filtering data", {"foo" => {"bar" => "val", "baz" => "val"}})
+# =>
+# ℹ info    Filtering data            foo={bar="[FILTERED]" baz="[FILTERED]"}
+```
+
+You can mix and match. To filter keys based on pattern inside a deeply nested hash use dot notation with regular expression. For example, to find keys for the `:foo` parent key that starts with `:b` character, we could do:
+
+```ruby
+logger = TTY::Logger.new do |config|
+  config.filters.data = [/^foo\.b/]
+end
+```
+
+Then only keys under the `:foo` key will be filtered:
+
+```ruby
+logger.info("Filtering data", {"foo" => {"bar" => "val"}, "baz" => {"bar" => val"}})
+# =>
+# ℹ info    Filtering data            foo={bar="[FILTERED]"} baz={bar=val}
+```
+
+### 2.5 Cloning
+
+You can create a copy of a logger with the current configuration using the `copy` method.
+
+For example, given the following logger with `:app` and `:env` data:
+
+```ruby
+logger = TTY::Logger.new(fields: {app: "parent", env: "prod"})
+```
+
+We can create a copy with a custom configuration that changes filtered message content and `:app` data:
+
+```ruby
+child_logger = logger.copy(app: "child") do |config|
+  config.filters = ["logging"]
+end
+```
+
+```ruby
+logger.info("Parent logging")
+child_logger.warn("Child logging")
+# =>
+# ℹ info    Parent logging            app=parent env=prod
+# ⚠ warning Child [FILTERED]          app=child env=prod
+```
+
+### 2.6 Handlers
 
 `TTY::Logger` supports many ways to handle log messages.
 
@@ -285,7 +518,7 @@ The available handlers by default are:
 * `:null` - discards any log messages
 * `:stream` - log messages to an `IO` stream, a file, a socket or a console.
 
-You can also implement your own [custom handler](#253-custom-handler).
+You can also implement your own [custom handler](#263-custom-handler).
 
 The handlers can be configured via global or instance configuration with `handlers`. The handler can be a name or a class name:
 
@@ -311,13 +544,16 @@ logger.add_handler(:console)
 logger.remove_handler(:console)
 ```
 
-#### 2.5.1 Console handler
+#### 2.6.1 Console Handler
 
 The console handler prints log messages to the console. It supports the following options:
 
 * `:styles` - a hash of styling options.
-* `:formatter` - the formatter for log messages. Defaults to `:text`
-* `:output` - the device to log error messages to. Defaults to `$stderr`
+* `:formatter` - the formatter for log messages. Defaults to `:text`.
+* `:output` - the device to log error messages to. Defaults to `$stderr`.
+* `:message_format` - uses `sprintf` format to display messages. Defaults to `"%-25s"`.
+* `:enable_color` - when `true` forces colored output, when `false` disables colored output.
+                    Defaults to `nil` which performs automatic terminal color support detection.
 
 The supported options in the `:styles` are:
 
@@ -326,9 +562,9 @@ The supported options in the `:styles` are:
 * `:color` - the color for the log message.
 * `:levelpad` - the extra amount of padding used to display log label.
 
-See the [TTY::Logger::Handlers::Console]() for full list of styles.
+See the [TTY::Logger::Handlers::Console](https://github.com/piotrmurach/tty-logger/blob/master/lib/tty/logger/handlers/console.rb) for full list of styles.
 
-Console handler has many defaults styles such as `success` and `error`:
+Console handler has many default styles such as `success` and `error`:
 
 ```ruby
 logger = TTY::Logger.new
@@ -339,7 +575,7 @@ logger.error("Default error")
 # ⨯ error   Default error
 ```
 
-You can change console handler default style with a tuple of handler name and options hash.
+You can change the default styling with a tuple of handler name and options hash.
 
 In our example, we want to change the styling of `success` and `error`:
 
@@ -353,7 +589,7 @@ new_styles = {
     error: {
       symbol: "!",
       label: "Dooh",
-      levelpad: 3
+      levelpad: 3 # the amount of extra padding to align level names in a column
     }
   }
 }
@@ -362,18 +598,27 @@ new_styles = {
 And then use the `new_styles` when providing `handlers` configuration:
 
 ```ruby
-new_style = TTY::Logger.new do |config|
-  config.handlers = [:console, new_styles]
+styled_logger = TTY::Logger.new do |config|
+  config.handlers = [[:console, new_styles]]
 end
 
-new_style.success("Custom success")
-new_style.error("Custom error")
+styled_logger.success("Custom success")
+styled_logger.error("Custom error")
 # =>
-+ Ohh yes Custom success
-! Dooh    Custom error
+# + Ohh yes Custom success
+# ! Dooh    Custom error
 ```
 
-#### 2.5.2 Stream handler
+To increase message padding to a percentage of terminal width (depends on [tty-screen](https://github.com/piotrmurach/tty-screen/)):
+
+```ruby
+TTY::Logger.new do |config|
+  padding = (TTY::Screen.columns * 0.4).to_i
+  config.handlers = [[:console, { message_format: "%-#{padding}s" }]]
+end
+```
+
+#### 2.6.2 Stream handler
 
 To send log event data outside of console to another service or `IO` stream, you can use `:stream` handler.
 
@@ -387,7 +632,7 @@ end
 By default, the output will be a plain text streamed to console. The text contains key and value pairs of all the metadata and the message of the log event.
 
 ```ruby
-loggger.info("Info about the deploy", app="myap", env="prod")
+logger.info("Info about the deploy", app:"myap", env:"prod")
 # =>
 # pid=18315 date="2019-07-21" time="15:42:12.463" path="examples/stream.rb:17:in`<main>`"
 # level=info message="Info about the deploy" app=myapp env=prod
@@ -405,13 +650,13 @@ end
 This will output JSON formatted text streamed to console.
 
 ```ruby
-loggger.info("Info about the deploy", app="myap", env="prod")
+logger.info("Info about the deploy", app="myap", env="prod")
 # =>
 # {"pid":18513,"date":"2019-07-21","time":"15:54:09.924","path":"examples/stream.rb:17:in`<main>`",
 # "level":"info","message":"Info about the deploy","app":"myapp","env":"prod"}
 ```
 
-#### 2.5.3 Custom Handler
+#### 2.6.3 Custom Handler
 
 You can create your own log event handler if the default ones don't match your needs.
 
@@ -471,7 +716,7 @@ logger = TTY::Logger.new
 logger.add_handler [MyHandler, label: "myhandler"]
 ```
 
-#### 2.5.4 Multiple Handlers
+#### 2.6.4 Multiple Handlers
 
 You can define as many handlers as you need. For example, you may log messages both to console and stream:
 
@@ -492,7 +737,7 @@ logger = TTY::Logger.new do |config|
 end
 ```
 
-### 2.6 Formatters
+### 2.7 Formatters
 
 The available formatters are:
 
@@ -514,7 +759,8 @@ TTY::Logger.new do |config|
   config.handlers = [:console, [:console, formatter: :json]]
 end
 ```
-### 2.7 Output Streams
+
+### 2.8 Output Streams
 
 By default all log events are output to `stderr`. You can change this using configuration `output` option. Any `IO`-like stream such as file, socket or console can be used. For example, to log all messages to a file do:
 
@@ -543,6 +789,12 @@ logger = TTY::Logger.new do |config|
 end
 ```
 
+## 3. Community Extensions
+
+### 3.1 Sentry Handler
+
+[tty-logger-raven](https://github.com/ianks/tty-logger-raven) provides an extension for Sentry.io.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.