`" # level=info message="Info about the deploy" app=myapp env=prod ``` You can change stream formatter for ease of working with external services such as `Logstash`. For example, to use `:stream` handler with `:json` format do: ```ruby logger = TTY::Logger.new(output: output) do |config| config.handlers = [[:stream, formatter: :json]] config.metadata = [:all] end ``` This will output JSON formatted text streamed to console. ```ruby loggger.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`

`", # "level":"info","message":"Info about the deploy","app":"myapp","env":"prod"} ``` #### 2.5.3 Custom Handler You can create your own log event handler if the default ones don't match your needs. The design of your handler should include two calls: * `initialize` - where all dependencies get injected * `call` - where the log event is handled We start with the implementation of the `initialize` method. This method by default is injected with `:config` key that includes all global configuration options. The `:output` key for displaying log message in the console and `:formatter`. In our case we also add custom `:label`: ```ruby class MyHandler def initialize(output: nil, config: nil, formatter: nil, label: nil) @label = label @output = output end end ``` Next is the `call` method that accepts the log `event`. The `event` has the following attributes: * `message` - the array of message parts to be printed * `fields` - the structured data supplied with the event * `metadata` - the additional info about the event. See [metadata](#241-metadata) section for details. We add implementation of `call`: ```ruby class MyHandler def initialize(output: nil, config: nil, label: nil) @label = label @output = output end def call(event) @output.puts "(#{@label}) #{event.message.join}" end end ``` Once you have your custom handler, you need to register it with the logger. You can do so using the `handlers` configuration option: ```ruby logger = TTY::Logger.new do |config| config.handlers = [[MyHandler, label: "myhandler"]] end ``` Or add your handler dynamically after logger initialization: ```ruby logger = TTY::Logger.new logger.add_handler [MyHandler, label: "myhandler"] ``` #### 2.5.4 Multiple Handlers You can define as many handlers as you need. For example, you may log messages both to console and stream: ```ruby logger = TTY::Logger.new do |config| config.handlers = [:console, :stream] end ``` Each handler can have its own configuration. For example, you can register `:console` handler to log messages above error level and `:stream` that logs any message with info or higher level: ```ruby logger = TTY::Logger.new do |config| config.handlers = [ [:console, level: :error], [:stream, level: :info] ] end ``` ### 2.6 Formatters The available formatters are: * `:json` * `:text` You can configure format for all the handlers: ```ruby TTY::Logger.new do |config| config.formatter = :json end ``` Or specify a different formatter for each handler. For example, let's say you want to log to console twice, once with default formatter and once with `:json` formatter: ```ruby TTY::Logger.new do |config| config.handlers = [:console, [:console, formatter: :json]] end ``` ### 2.7 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: ```ruby logger = TTY::Logger.new do |config| config.output = File.open("errors.log", "a") end ``` You can also specify multiple streams that all log messages will be sent to: ```ruby logger = TTY::Logger.new do |config| config.output = [$stderr, File.open("errors.log", "a")] end ``` Conversely, you can specify different output for each of the handlers used. For example, you can output all messages above info level to a file with a stream handler and only show error messages in the console with a nicely formatted output. ```ruby logger = TTY::Logger.new do |config| config.handlers = [ [:console, output: $stderr, level: :error], [:stream, output: File.open("errors.log", "a"), level: :info)] ] end ``` ## 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. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/tty-logger. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct. ## License The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT). ## Code of Conduct Everyone interacting in the TTY::Logger project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/tty-logger/blob/master/CODE_OF_CONDUCT.md). ## Copyright Copyright (c) 2019 Piotr Murach. See LICENSE for further details.