timber 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8580577f8c85abeb5eacec510136a2bf05d72406
+  data.tar.gz: 7a08aa6f00eda500d016c413ccf2b95d759b9266
+SHA512:
+  metadata.gz: b906867c8198c1d94052856b6e7b402af88bd252b770ed9a8a33aae7284a3f562569f4fde7202c759eb786e28f8b85b0b5a2b1ab8c2b5d63bde56f1ee686d404
+  data.tar.gz: d4afc694df19c1c90a4711b7d1762bb0f203cf4521aa44a1f63d5e7f66c8cef37258f7af2c8e6fb73b166305aa43a1b4bfce3a2ea0c625e1951e9bc0726657dc

data/.gitignore

@@ -0,0 +1,15 @@
+.DS_Store
+.rvmrc
+.ruby-version
+coverage
+Gemfile.lock
+*.swp
+*.gem
+
+/.bundle
+/.yardoc
+/doc
+/gemfiles
+/log
+/tmp
+/pkg

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order rand

data/.yardopts

@@ -0,0 +1,6 @@
+--protected
+--no-private
+--embed-mixin ClassMethods
+-
+LICENSE.md
+README.md

data/Appraisals

@@ -0,0 +1,41 @@
+appraise "rails-2.3.X" do
+  gem "rails", "~> 2.3.18"
+end
+
+appraise "rails-3.0.X" do
+  gem "rails", "~> 3.0.20"
+end
+
+appraise "rails-3.1.X" do
+  gem "rails", "~> 3.1.12"
+end
+
+appraise "rails-3.2.X" do
+  gem "rails", "~> 3.2.22"
+end
+
+appraise "rails-4.0.X" do
+  gem "minitest"
+  gem "rails", "~> 4.0.13"
+end
+
+appraise "rails-4.1.X" do
+  gem "minitest"
+  gem "rails", "~> 4.1.15"
+end
+
+appraise "rails-4.2.X" do
+  gem "minitest"
+  gem "rails", "~> 4.2.7"
+end
+
+appraise "rails-5.0.X" do
+  gem "minitest"
+  gem "rails", "~> 5.0.0"
+end
+
+appraise "rails-edge" do
+  gem 'rack', github: 'rack/rack', branch: 'master'
+  gem 'arel', github: 'rails/arel', branch: 'master'
+  gem 'rails', github: 'rails/rails', branch: 'master'
+end

data/Gemfile

@@ -0,0 +1,30 @@
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'appraisal'
+  gem 'coveralls', require: false
+  gem 'json', '~> 1'
+  gem 'pry'
+  gem 'rails_stdout_logging'
+  gem 'rake'
+  gem 'rspec', '~> 3.4'
+  gem 'rspec-its'
+  gem 'simplecov', require: false
+  gem 'sqlite3'
+  gem 'terminal-table'
+  gem 'timecop'
+
+  ruby_version = Gem::Version.new("#{RUBY_VERSION}")
+  if ruby_version < Gem::Version.new("2.0.0")
+    gem 'public_suffix', '~> 1.4.6'
+    gem 'term-ansicolor', '~> 1.3.2'
+    gem 'webmock', '~> 2.2.0'
+  else
+    gem 'webmock'
+  end
+
+  # for coveralls
+  gem 'rest-client', '~> 1.8' # >= 2.0 requires ruby 2+, we have tests for 1.9
+  gem 'tins', '~> 1.6.0' # > 1.6 requires ruby 2+, we have tests for 1.9
+end

data/LICENSE.md

@@ -0,0 +1,15 @@
+# License
+
+Copyright (c) 2016, Timber Technologies, Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any purpose
+with or without fee is hereby granted, provided that the above copyright notice
+and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.

data/README.md

@@ -0,0 +1,194 @@
+# Timber
+
+<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>
+</p>
+
+[![CircleCI](https://circleci.com/gh/timberio/timber-ruby.svg?style=shield&circle-token=:circle-token)](https://circleci.com/gh/timberio/timber-ruby/tree/master)
+[![Coverage Status](https://coveralls.io/repos/github/timberio/timber-ruby/badge.svg?branch=master)](https://coveralls.io/github/timberio/timber-ruby?branch=master)
+[![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)
+
+
+1. [What is timber?](#what-is-timber)
+1. [How does it work?](#what-is-timber)
+2. [Logging Custom Events](#logging-custom-events)
+3. [The Timber Console / Pricing](#the-timber-console-pricing)
+2. [Install](#install)
+
+
+## What is Timber?
+
+Timber automatically structures your logs with events and context in a non-proprietary JSON format.
+It’s simple, quick, managed, and has absolutely no risk of code debt or lock-in.
+It’s just good ol’ logging.
+
+Timber’s philosophy is that application insight should be open and owned by you.
+And there is no better vehicle than logging:
+
+1. It’s a shared practice that has been around since the dawn of computers.
+2. It’s baked into every language, library, and framework. Even your own apps.
+3. The data is entirely owned by you.
+
+The problem is that logs are messy, noisy, and hard to use. Timber solves this by being
+application aware, properly structuring your logs, and optionally providing a [fast, modern,
+and beautiful console](https://timber.io) -- allowing you to realize the power of
+your logs.
+
+
+## How does it work?
+
+Glad you asked! :) Timber automatically structures your logs by taking advantage of public APIs.
+
+For example, by subscribing to `ActiveSupport::Notifications`, Timber can automatically turn this:
+
+```
+Completed 200 OK in 117ms (Views: 85.2ms | ActiveRecord: 25.3ms)
+```
+
+Into this:
+
+```json
+{
+  "dt": "2016-12-01T02:23:12.236543Z",
+  "level": "info",
+  "message": "Completed 200 OK in 117ms (Views: 85.2ms | ActiveRecord: 25.3ms)",
+  "context": {
+    "http": {
+      "method": "GET",
+      "path": "/checkout",
+      "remote_addr": "123.456.789.10",
+      "request_id": "abcd1234"
+    },
+    "user": {
+      "id": 2,
+      "name": "Ben Johnson",
+      "email": "ben@johnson.com"
+    }
+  },
+  "event": {
+    "http_response": {
+      "status": 200,
+      "time_ms": 117
+    }
+  }
+}
+```
+
+It does the same for `http requests`, `sql queries`, `exceptions`, `template renderings`,
+and any other event your framework logs. (for a full list see `Timber::Events`)
+
+
+## Logging Custom Events
+
+> Another service? More code debt? :*(
+
+Nope! Logging custom events is Just Logging™. Check it out:
+
+```ruby
+# Simple string (original Logger interface remains untouched)
+Logger.warn "Payment rejected for customer abcd1234, reason: Card expired"
+
+# Structured hash
+Logger.warn message: "Payment rejected", type: :payment_rejected,
+  data: %{customer_id: "abcd1234", amount: 100, reason: "Card expired"}
+
+# Using a Struct
+PaymentRejectedEvent = Struct.new(:customer_id, :amount, :reason) do
+  def message; "Payment rejected for #{customer_id}"; end
+  def type; :payment_rejected; end
+end
+Logger.warn PaymentRejectedEvent.new("abcd1234", 100, "Card expired")
+```
+
+(for more examples, see the `Timber::Logger` docs)
+
+No mention of Timber anywhere! In fact, this approach pushes things the opposite way. What if,
+as a result of structured logging, you could start decoupling other services from your application?
+
+Before:
+
+```
+               |---[HTTP]---> sentry / bugsnag / etc
+My Application |---[HTTP]---> librato / graphite / etc
+               |---[HTTP]---> new relic / etc
+               |--[STDOUT]--> logs
+                                |---> Logging service
+                                |---> S3
+                                |---> RedShift
+```
+
+
+After:
+
+```
+                                                    |-- sentry / bugsnag / etc
+                                                    |-- librato / graphite / etc
+My Application |--[STDOUT]--> logs ---> Timber ---> |-- new relic / etc
+                               ^                    |-- S3
+                               |                    |-- RedShift
+                               |                                 ^
+                    fast, efficient, durable,                    |
+                     replayable, auditable,        change any of these without
+                          just logging                  touching your code
+                                                       *and* backfill them!
+```
+
+[Mind-blown!](http://i.giphy.com/EldfH1VJdbrwY.gif)
+
+
+
+## The Timber Console / Pricing
+
+> This is all gravy, but wouldn't the extra data get expensive?
+
+If you opt use the [Timber Console](https://timber.io), we only charge for
+the size of the `message`, `dt`, and `event.custom` attributes. Everything else is
+stored at no cost to you. [Say wha?!](http://i.giphy.com/l0HlL2vlfpWI0meJi.gif). This ensures
+pricing remains predictable. We charge per GB sent to us and retained. No user limits,
+no weird feature matrixes, just data. Finally, the data is yours, in a simple
+non-proprietary JSON format that you can export to S3, Redshift, or any of our other integrations.
+
+For more details checkout out [timber.io](https://timber.io).
+
+## Install
+
+### 1. Install the gem:
+
+```ruby
+# Gemfile
+gem 'timber'
+```
+
+### 2. Install the logger:
+
+#### Heroku:
+
+```ruby
+# config/environments/production.rb (or staging, etc)
+config.logger = Timber::Logger.new(STDOUT)
+```
+
+The command to add your log drain will be displayed in the [Timber app](https://app.timber.io)
+after you add your application.
+
+#### Non-Heroku:
+
+```ruby
+# config/environments/production.rb (or staging, etc)
+log_device = Timber::LogDevices::HTTP.new(ENV['TIMBER_KEY']) # key can be obtained by signing up at https://timber.io
+config.logger = Timber::Logger.new(log_device)
+```
+
+Your Timber application key will be displayed in the [Timber app](https://app.timber.io)
+after you add your application.
+
+
+*Other transport methods coming soon!*
+
+---
+
+That's it! Log to your heart's content.
+
+For documentation on logging structured events, and other features,
+checkout [the docs](http://thedocs.com/). For more information on Timber visit [timber.io](https://timber.io).

data/circle.yml

@@ -0,0 +1,33 @@
+machine:
+  environment:
+    COVERALLS_REPO_TOKEN: fzLA6t2EFT4KBemv3du0AdHGcqTzyRzlr
+
+dependencies:
+  override:
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal generate
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-2.3.X bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-3.0.X bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-3.1.X bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-3.2.X bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 appraisal install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 bundle install
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 appraisal install
+
+test:
+  override:
+    - RAILS_23=true PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-2.3.X rspec --tag rails_23
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-3.0.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-3.1.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-1.9.3-p448/bin:$PATH rvm-exec 1.9.3 appraisal rails-3.2.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 appraisal rails-4.0.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 appraisal rails-4.1.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 appraisal rails-4.2.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 appraisal rails-5.0.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.2.6/bin:$PATH rvm-exec 2.2.6 appraisal rails-edge rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 appraisal rails-4.0.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 appraisal rails-4.1.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 appraisal rails-4.2.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 appraisal rails-5.0.X rspec
+    - PATH=/home/ubuntu/.rvm/gems/ruby-2.3.3/bin:$PATH rvm-exec 2.3.3 appraisal rails-edge rspec

data/lib/timber/config.rb

@@ -0,0 +1,18 @@
+require "singleton"
+
+module Timber
+  # Interface for configuring Timber.
+  #
+  # @note If using rails this will be installed in the `config` object via `config.timber`.
+  class Config
+    include Singleton
+
+    attr_writer :logger
+
+    # Set a logger to view internal Timber library log message.
+    # Useful for debugging. Defaults to `::Logger.new(nil)`.
+    def logger
+      @logger ||= Logger.new(nil)
+    end
+  end
+end

data/lib/timber/context.rb

@@ -0,0 +1,17 @@
+module Timber
+  # Base class for all `Timber::Contexts::*` classes.
+  # @private
+  class Context
+    def keyspace
+      raise NoImplementedError.new
+    end
+
+    def as_json(options = {})
+      raise NotImplementedError.new
+    end
+
+    def to_json(options = {})
+      Util::Hash.compact(as_json).to_json(options)
+    end
+  end
+end

data/lib/timber/contexts/custom.rb

@@ -0,0 +1,27 @@
+module Timber
+  module Contexts
+    # Custom contexts allow you to add application specific context not covered elsewhere.
+    #
+    # @example Adding a context
+    #   custom_context = Timber::Contexts::Custom.new(type: :keyspace, data: %{my: "data"})
+    #   Timber::CurrentContext.with(custom_context) do
+    #     # ... anything logged here will have the context ...
+    #   end
+    class Custom < Context
+      attr_reader :type, :data
+
+      def initialize(attributes)
+        @type = attributes[:type] || raise(ArgumentError.new(":type is required"))
+        @data = attributes[:data] || raise(ArgumentError.new(":data is required"))
+      end
+
+      def keyspace
+        :custom
+      end
+
+      def as_json(_options = {})
+        {type => data}
+      end
+    end
+  end
+end

data/lib/timber/contexts/http.rb

@@ -0,0 +1,28 @@
+module Timber
+  module Contexts
+    # The HTTP content tracks the current HTTP request being processed. This serves
+    # as join data across your logs, allowing you to query all logs for any attribute
+    # presented here. For example, viewing all logs for a given request_id.
+    #
+    # @note This context should be installed automatically through probes,
+    #   such as the {Probes::RackHTTPContext} probe.
+    class HTTP < Context
+      attr_reader :method, :path, :remote_addr, :request_id
+
+      def initialize(attributes)
+        @method = attributes[:method] || raise(ArgumentError.new(":method is required"))
+        @path = attributes[:path] || raise(ArgumentError.new(":path is required"))
+        @remote_addr = attributes[:remote_addr]
+        @request_id = attributes[:request_id]
+      end
+
+      def keyspace
+        :http
+      end
+
+      def as_json(_options = {})
+        {:method => method, :path => path, :remote_addr => remote_addr, :request_id => request_id}
+      end
+    end
+  end
+end

data/lib/timber/contexts/organization.rb

@@ -0,0 +1,35 @@
+module Timber
+  module Contexts
+    # The organization context tracks the organization of the currently
+    # authenticated user.
+    #
+    # You will want to add this context at the time you determine
+    # the organization a user belongs to, typically in the authentication
+    # flow.
+    #
+    # Example:
+    #
+    #   organization_context = Timber::Contexts::Organization.new(id: "abc1234", name: "Timber Inc")
+    #   Timber::CurrentContext.with(organization_context) do
+    #     # Logging will automatically include this context
+    #     logger.info("This is a log message")
+    #   end
+    #
+    class Organization < Context
+      attr_reader :id, :name
+
+      def initialize(attributes)
+        @id = attributes[:id]
+        @name = attributes[:name]
+      end
+
+      def keyspace
+        :organization
+      end
+
+      def as_json(_options = {})
+        {id: id, name: name}
+      end
+    end
+  end
+end

data/lib/timber/contexts/user.rb

@@ -0,0 +1,36 @@
+module Timber
+  module Contexts
+    # The user context tracks the currently authenticated user.
+    #
+    # You will want to add this context at the time log the user in, typically
+    # during the authentication flow.
+    #
+    # Note: Timber will attempt to automatically add this if you add a #current_user
+    # method to your controllers. Most authentication solutions do this for you automatically.
+    #
+    # Example:
+    #
+    #   user_context = Timber::Contexts::User.new(id: "abc1234", name: "Ben Johnson")
+    #   Timber::CurrentContext.with(user_context) do
+    #     # Logging will automatically include this context
+    #     logger.info("This is a log message")
+    #   end
+    #
+    class User < Context
+      attr_reader :id, :name
+
+      def initialize(attributes)
+        @id = attributes[:id]
+        @name = attributes[:name]
+      end
+
+      def keyspace
+        :user
+      end
+
+      def as_json(_options = {})
+        {id: id, name: name}
+      end
+    end
+  end
+end

data/lib/timber/contexts.rb

@@ -0,0 +1,10 @@
+require "timber/contexts/custom"
+require "timber/contexts/http"
+require "timber/contexts/organization"
+require "timber/contexts/user"
+
+module Timber
+  # @private
+  module Contexts
+  end
+end

data/lib/timber/current_context.rb

@@ -0,0 +1,43 @@
+require "singleton"
+
+module Timber
+  # Holds the current context in a thread safe memory storage. This context is
+  # appended to every log line. Think of context as join data between your log lines,
+  # allowing you to relate them and filter them appropriately.
+  class CurrentContext
+    include Singleton
+
+    THREAD_NAMESPACE = :_timber_current_context.freeze
+
+    class << self
+      # Convenience method for {#with}.
+      #
+      # @example Adding a context
+      #   custom_context = Timber::Contexts::Custom.new(type: :keyspace, data: %{my: "data"})
+      #   Timber::CurrentContext.with(custom_context) do
+      #     # ... anything logged here will have the context ...
+      #   end
+      def with(*args, &block)
+        instance.with(*args, &block)
+      end
+    end
+
+    # Adds a context to the current stack.
+    def with(data)
+      key = data.keyspace
+      hash[key] = data
+      yield
+    ensure
+      hash.delete(key)
+    end
+
+    def snapshot
+      hash.clone
+    end
+
+    private
+      def hash
+        Thread.current[THREAD_NAMESPACE] ||= {}
+      end
+  end
+end

data/lib/timber/event.rb

@@ -0,0 +1,17 @@
+module Timber
+  # Base class for `Timber::Events::*`
+  # @private
+  class Event
+    def message
+      raise NotImplementedError.new
+    end
+
+    def as_json(options = {})
+      raise NotImplementedError.new
+    end
+
+    def to_json(options = {})
+      Util::Hash.compact(as_json).to_json(options)
+    end
+  end
+end

data/lib/timber/events/controller_call.rb

@@ -0,0 +1,40 @@
+module Timber
+  module Events
+    # The controller call event tracks controller invocations. For example, this line in Rails:
+    #
+    #   Processing by PagesController#home as HTML
+    #
+    # @note This event should be installed automatically through probes,
+    #   such as the {Probes::ActionControllerLogSubscriber} probe.
+    class ControllerCall < Timber::Event
+      attr_reader :controller, :action, :params, :format
+
+      def initialize(attributes)
+        @controller = attributes[:controller] || raise(ArgumentError.new(":controller is required"))
+        @action = attributes[:action] || raise(ArgumentError.new(":action is required"))
+        @params = attributes[:params]
+        @format = attributes[:format]
+      end
+
+      def to_hash
+        {controller: controller, action: action}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:controller_call => to_hash}
+      end
+
+      def message
+        message = "Processing by #{controller}##{action}"
+        if !message.nil?
+          message << " as #{format}"
+        end
+        if !params.nil? && params.length > 0
+          message << "\n  Parameters: #{params.inspect}"
+        end
+        message
+      end
+    end
+  end
+end

data/lib/timber/events/custom.rb

@@ -0,0 +1,42 @@
+module Timber
+  module Events
+    # Allows for custom events that aren't covered elsewhere.
+    #
+    # Custom events can be used to encode information about events that are central
+    # to your line of business like receiving credit card payments, saving a draft of a post,
+    # or changing a user's password.
+    #
+    # For examples of logging custom events see {Logger}.
+    class Custom < Timber::Event
+      attr_reader :type, :message, :data
+
+      # Instantiates a new custom event that can be logged. See {Logger} for examples
+      # on logging custom events.
+      #
+      # @param [Hash] attributes the options to create a custom event with.
+      # @option attributes [Symbol] :type *required* The custom event type. This should be in
+      #   snake case. Example: `:my_custom_event`.
+      # @option attributes [String] :message *required* The message to be logged.
+      # @option attributes [Hash] :data A hash of JSON encodable data to be stored with the
+      #   log line.
+      def initialize(attributes)
+        @type = attributes[:type] || raise(ArgumentError.new(":type is required"))
+        @message = attributes[:message] || raise(ArgumentError.new(":message is required"))
+        @data = attributes[:data]
+      end
+
+      def to_hash
+        {type => data}
+      end
+      alias to_h to_hash
+
+      def as_json(_options = {})
+        {:custom => to_hash}
+      end
+
+      def to_json(options = {})
+        as_json().to_json(options)
+      end
+    end
+  end
+end