tracer_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 824a991b553db0aefd11d0f2d83dafffd9435b28
+  data.tar.gz: 64248db71c319412b85f8be5e32187c7fe40530e
+SHA512:
+  metadata.gz: 2475d3fa342a85d8564869043e85df849fe4cf9f35e8ab96e5b08813293a30e11e6da473ea866eb623c93df8cdadc25d7806ce265a42a8075cc3193c6d25ed26
+  data.tar.gz: a718a7a74831aee0f0d6aa13fa1d5d7851f1be9cf91cf91ab09c15a45c5a64e7696c56810fdecd4c06587e3756c7c85b4c116a6ba84f87f5e18e201121fa397d

data/.gitignore

@@ -0,0 +1,10 @@
+/,idea/
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.idea/.name

@@ -0,0 +1 @@
+tracer_client

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tracer_client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Serge Galanin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# TracerClient
+
+Library for logging errors and ActiveRecord object changes to Tracer.
+ 
+Tracer is a web application for accumulating, showing and analyzing of a vital application information.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tracer_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tracer_client
+
+## Usage
+
+Methods for debugging:
+
+```ruby
+Log.debug('Debug message') # log simple message
+Log.debug({a: 2, b: 5})    # log hash values
+Log.debug(any_object)      # log any object
+```
+
+Log some info with severity level. Each method requires message text and log tags and accepts optional data. 
+```ruby
+Log.info('Order created', 'order create', id: id)
+Log.warn('Order shipping too long!', 'order shipping', id: id)
+Log.error('Order was not paid', 'order payment', id: id)
+```
+
+Log catched exception
+```ruby
+begin
+    raise 'Some exception'
+rescue => e
+    Log.exception(e, 'Unable to send request', 'request', request_data: data)
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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/galanin/tracer_client.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tracer_client"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tracer_client.rb

@@ -0,0 +1,5 @@
+require 'tracer_client/version'
+require 'tracer_client/server'
+require 'tracer_client/client'
+require 'tracer_client/log'
+require 'tracer_client/changes'

data/lib/tracer_client/changes.rb

@@ -0,0 +1,177 @@
+module Tracer
+  module Changes
+
+    def self.included(base)
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      def log_record_changes(options = {})
+        send :include, InstanceMethods
+
+        class_attribute :changes_logging_options
+        self.changes_logging_options = options.dup
+
+        %i(ignore skip only).each do |k|
+          changes_logging_options[k] =
+              [changes_logging_options[k]].flatten.compact.map { |attr| attr.is_a?(Hash) ? attr.stringify_keys : attr.to_s }
+        end
+
+        options_on = Array(options[:on]) # so that a single symbol can be passed in without wrapping it in an `Array`
+
+        after_create  :log_create, :if => :log_changes? if options_on.empty? || options_on.include?(:create)
+
+        if options_on.empty? || options_on.include?(:update)
+          before_update :log_update, :if => :log_changes?
+        end
+
+        after_destroy :log_destroy, :if => :log_changes? if options_on.empty? || options_on.include?(:destroy)
+      end
+
+    end
+
+
+    module InstanceMethods
+
+      private
+
+
+      def log_create
+        Tracer::Client.log_changes(
+            item_id:   id,
+            item_type: self.class.base_class.name,
+            event:     'create',
+            changes:   changes_for_tracing,
+        )
+      rescue Exception => e
+        Log.exception_with_alert(e, 'Ошибка регистрации создания', 'log_changes create',
+                                 item_id:   id,
+                                 item_type: self.class.base_class.name)
+      end
+
+
+      def log_update
+        if changed_notably?
+          Tracer::Client.log_changes(
+              item_id:   id,
+              item_type: self.class.base_class.name,
+              event:     'update',
+              object:    object_attrs_for_tracing(item_before_change),
+              changes:   changes_for_tracing,
+          )
+        end
+      rescue Exception => e
+        Log.exception_with_alert(e, 'Ошибка регистрации изменения', 'log_changes update',
+                                 item_id:   id,
+                                 item_type: self.class.base_class.name)
+      end
+
+
+      def log_destroy
+        if persisted?
+          Tracer::Client.log_changes(
+              item_id:   id,
+              item_type: self.class.base_class.name,
+              event:     'destroy',
+              object:    object_attrs_for_tracing(item_before_change),
+          )
+        end
+      rescue Exception => e
+        Log.exception_with_alert(e, 'Ошибка регистрации удаления', 'log_changes destroy',
+                                 item_id:   id,
+                                 item_type: self.class.base_class.name)
+      end
+
+
+      def object_attrs_for_tracing(object)
+        object_attrs = object.attributes.except(*changes_logging_options[:skip]).with_indifferent_access
+
+        unwrap_serialized_attributes(object_attrs) do |object_attrs, values, attr|
+          object_attrs[attr] = values[attr] if values.key?(attr)
+        end
+
+        object_attrs.as_json
+      end
+
+
+      def changes_for_tracing
+        changed = self.changes.delete_if do |key, value|
+          !notably_changed.include?(key)
+        end
+
+        unwrap_serialized_attributes(changed) do |changed, (a, b), attr|
+          if (a.key?(attr) || b.key?(attr)) && a[attr] != b[attr]
+            changed[attr] = [a[attr], b[attr]]
+          end
+        end
+
+        changed.as_json
+      end
+
+
+      # attrs должны быть либо с ключами-символами, либо HashWithIndifferentAccess
+      def unwrap_serialized_attributes(attrs)
+        stored_attrs = self.class.stored_attributes
+        serialized = attrs.extract!(*stored_attrs.keys)
+
+        serialized.each do |store_attr, value|
+          stored_attrs[store_attr.to_sym].each do |attr|
+            yield(attrs, value, attr)
+          end
+        end
+      end
+
+
+      def item_before_change
+        previous = self.dup
+        # `dup` clears timestamps so we add them back.
+        all_timestamp_attributes.each do |column|
+          previous[column] = send(column) if self.class.column_names.include?(column.to_s) and not send(column).nil?
+        end
+        previous.tap do |prev|
+          prev.id = id # `dup` clears the `id` so we add that back
+          changed_attributes.select { |k,v| self.class.column_names.include?(k) }.each { |attr, before| prev[attr] = before }
+        end
+      end
+
+
+      def changed_notably?
+        notably_changed.any?
+      end
+
+
+      def notably_changed
+        only = self.changes_logging_options[:only].dup
+        # remove Hash arguments and then evaluate whether the attributes (the keys of the hash) should also get pushed into the collection
+        only.delete_if do |obj|
+          obj.is_a?(Hash) && obj.each { |attr, condition| only << attr if condition.respond_to?(:call) && condition.call(self) }
+        end
+        only.empty? ? changed_and_not_ignored : (changed_and_not_ignored & only)
+      end
+
+      def changed_and_not_ignored
+        ignore = self.changes_logging_options[:ignore].dup
+        # remove Hash arguments and then evaluate whether the attributes (the keys of the hash) should also get pushed into the collection
+        ignore.delete_if do |obj|
+          obj.is_a?(Hash) && obj.each { |attr, condition| ignore << attr if condition.respond_to?(:call) && condition.call(self) }
+        end
+        skip = self.changes_logging_options[:skip]
+        changed - ignore - skip
+      end
+
+    end
+
+
+    def log_changes?
+      if_condition     = self.changes_logging_options[:if]
+      unless_condition = self.changes_logging_options[:unless]
+      (if_condition.blank? || if_condition.call(self)) && !unless_condition.try(:call, self)
+    end
+
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  include Tracer::Changes
+end

data/lib/tracer_client/client.rb

@@ -0,0 +1,122 @@
+module Tracer
+  module Client
+
+    class << self
+
+      def start_request(current_user, request, params, session)
+        Thread.current[:tracer_current_user] = current_user
+        Thread.current[:tracer_request] = request
+        Thread.current[:tracer_params] = get_params(params)
+      end
+
+
+      def end_request
+        Thread.current[:tracer_current_user] = nil
+        Thread.current[:tracer_request] = nil
+        Thread.current[:tracer_params] = nil
+      end
+
+
+      def log(notice)
+        LogJob.new.async.perform(notice.merge(request_log_data))
+      end
+
+
+      def log_changes(changes)
+        LogChangesJob.new.async.perform(changes.merge(request_changes_data))
+      end
+
+
+      private
+
+
+      def get_params(params)
+        @parameter_filter ||= ActionDispatch::Http::ParameterFilter.new Rails.application.config.filter_parameters
+        @parameter_filter.filter(params.except(:utf8, :authenticity_token, :_method)).symbolize_keys
+      end
+
+
+      def request_data
+        data = {context: {}}
+
+        request = Thread.current[:tracer_request]
+        if request
+          data[:context].merge!(
+              url:        request.original_url,
+              referer:    request.headers['Referer'],
+              user_agent: request.headers['User-Agent'],
+              ip:         request.remote_ip,
+              method:     request.request_method,
+              request_id: request.uuid,
+              headers:    {
+                  accept: request.headers['Accept'],
+              }
+          )
+        end
+
+        cookies = Thread.current[:cookies]
+        if cookies && cookies[:administrator_id]
+          data[:context][:cookies] = {
+              administrator_id: cookies.signed[:administrator_id]
+          }
+        end
+
+        current_user = Thread.current[:tracer_current_user]
+        if current_user
+          data[:context].merge!(
+              userType: current_user[:type],
+              userId:   current_user[:id],
+          )
+        end
+
+        params = Thread.current[:tracer_params]
+        if params
+          data[:context].merge!(
+              component: params[:controller],
+              action:    params[:action],
+          )
+          data[:params] = params.except(:controller, :action)
+        end
+
+        data[:context].merge!(
+            environment:   Rails.env,
+            rootDirectory: Rails.root,
+        )
+
+        data
+      end
+
+
+      def request_log_data
+        request_data
+      end
+
+
+      def request_changes_data
+        request_data
+      end
+
+    end
+
+
+    private
+
+
+    class LogJob
+      include SuckerPunch::Job
+
+      def perform(notice)
+        Tracer::Server.log(notice)
+      end
+    end
+
+    class LogChangesJob
+      include SuckerPunch::Job
+
+      def perform(changes)
+        Tracer::Server.log_changes(changes)
+      end
+    end
+
+  end
+end

data/lib/tracer_client/errors/api_error.rb

@@ -0,0 +1,2 @@
+class ApiError < ApplicationError
+end

data/lib/tracer_client/errors/api_error_alert.rb

@@ -0,0 +1,2 @@
+class ApiErrorAlert < ApiErrorLog
+end

data/lib/tracer_client/errors/api_error_log.rb

@@ -0,0 +1,2 @@
+class ApiErrorLog < ApiError
+end

data/lib/tracer_client/errors/api_request_failure.rb

@@ -0,0 +1,15 @@
+class ApiRequestFailure < ApiError
+
+  def initialize(subject, tags, response, data = {})
+    super(subject, tags, data.merge({
+                                        api_response: {
+                                            status: response.code + ' ' + response.message,
+                                            type:   response.content_type,
+                                            length: response.content_length,
+                                            body:   response.body.force_encoding('UTF-8'),
+
+                                        },
+                                    }))
+  end
+
+end

data/lib/tracer_client/errors/api_request_failure_alert.rb

@@ -0,0 +1,2 @@
+class ApiRequestFailureAlert < ApiRequestFailureLog
+end

data/lib/tracer_client/errors/api_request_failure_log.rb

@@ -0,0 +1,2 @@
+class ApiRequestFailureLog < ApiRequestFailure
+end

data/lib/tracer_client/errors/application_error.rb

@@ -0,0 +1,28 @@
+class ApplicationError < StandardError
+
+  attr_reader :tags, :data
+
+
+  def initialize(subject, tags = '', data = {})
+    super(subject)
+    @tags = tags
+    @data = data
+
+    puts "#{'-'*10}\n#{@data}\n#{'-'*10}" if Rails.env.development?
+
+    Log.on_raise(self, caller(2))
+  end
+
+
+  # для логирования при бросании и в дефолтном обработчике
+  def with_log?
+    self.class.name.end_with?('Log', 'Alert')
+  end
+
+
+  # для логирования при бросании и в дефолтном обработчике
+  def with_alert?
+    self.class.name.end_with?('Alert')
+  end
+
+end

data/lib/tracer_client/errors/logic_error.rb

@@ -0,0 +1,2 @@
+class LogicError < ApplicationError
+end

data/lib/tracer_client/errors/logic_error_alert.rb

@@ -0,0 +1,2 @@
+class LogicErrorAlert < LogicErrorLog
+end

data/lib/tracer_client/errors/logic_error_log.rb

@@ -0,0 +1,2 @@
+class LogicErrorLog < LogicError
+end

data/lib/tracer_client/log.rb

@@ -0,0 +1,153 @@
+require 'config'
+
+module Log
+
+  # error - ошибки
+  # crit  - исключения
+  # emerg - неперехваченные исключения
+  SEVERITIES = %i(debug info notice warn error crit alert emerg)
+  FACILITIES = %i(request lib auth user product order line_item delivery odkl email direct_mail page exception)
+
+  ROBOT_UA_FRAGMENTS = /AhrefsBot|bingbot|DotBot|Googlebot|Mail.RU_Bot|MJ12bot|msnbot|SputnikBot|updown_tester|Web-Monitoring|WebMasterAid|YaDirectFetcher|YandexBot/
+
+
+  def self.start_request(current_user, request, params, session, do_log_request)
+    Tracer::Client.start_request(current_user, request, params, session)
+
+    info('HTTP запрос', 'http_request') if do_log_request
+
+    Thread.current[:request_tags] = %w(robot) if request.headers['User-Agent'] =~ ROBOT_UA_FRAGMENTS
+  end
+
+  def self.end_request
+    Thread.current[:request_tags] = nil
+    Tracer::Client.end_request
+  end
+
+
+  # Можно вызывать в сокращённой форме:
+  # Log.debug('Сообщение')
+  # Log.debug({a: 2, b: 5})
+  # Log.debug(any_object)
+  def self.debug(subject = '', tags = '', data = {})
+    if Hash === subject
+      # передан только хэш с данными
+      message(:debug, subject.inspect[0...40], '', subject, caller)
+    elsif String === subject
+      # передан только subject
+      message(:debug, subject, tags, data, caller)
+    else
+      # переданы некие другие данные
+      message(:debug, subject.inspect[0...40], '', {debug: subject}, caller)
+    end
+  end
+
+
+  %i(info warn error).each do |base_method|
+    instance_eval <<-CODE, __FILE__, __LINE__ + 1
+      def #{base_method}(subject, tags = '', data = {})
+        message(:#{base_method}, subject, tags, data, caller)
+      end
+
+      def #{base_method}_with_alert(subject, tags = '', data = {})
+        message(:#{base_method}, subject, tags, data.merge(with_alert: true), caller)
+      end
+    CODE
+  end
+
+
+  def self.exception(exception, subject, tags = '', data = {})
+    exception_message(exception, :crit, subject, tags, data, exception.backtrace)
+    exception
+  end
+
+
+  def self.exception_with_alert(exception, subject, tags = '', data = {})
+    exception(exception, subject, tags, data.merge(with_alert: true))
+  end
+
+
+  def self.on_raise(exception, backtrace)
+    if exception.with_log?
+      exception_message(exception, :warn, '', 'raise', {with_alert: exception.with_alert?}, backtrace)
+    end
+  end
+
+
+  def self.unhandled(exception)
+    if exception.with_log? && !exception.logged?
+      exception_message(exception, :emerg, '', 'unhandled', {with_alert: exception.with_alert?}, exception.backtrace)
+    end
+  end
+
+
+  private
+
+
+  def self.message(severity, subject, tags, data, backtrace)
+    return unless log?(severity)
+
+    tags = (Thread.current[:request_tags] || []) + tags.split(' ')
+
+    data = {data: data} unless Hash === data
+
+    return if data.key?(:exception) && data[:exception][:class] == 'ActiveRecord::RecordNotFound' && tags == %w(robot)
+
+    error_hash = {
+        severity:          severity,
+        tags:              tags,
+        message:           subject,
+        backtrace: get_backtrace(backtrace).first(10)
+    }
+
+    if data.key?(:exception)
+      error_hash[:exception_message] = data[:exception][:message].strip
+      error_hash[:type]              = data[:exception][:class]
+    end
+
+    Tracer::Client.log(
+        errors: [error_hash],
+        data:       data.except(:exception, :with_alert),
+        with_alert: data[:with_alert],
+    )
+  end
+
+
+  def self.exception_message(exception, severity, subject, tags, data, backtrace)
+    tags = (tags + ' ' + exception.tags).strip if exception.respond_to?(:tags)
+    data.merge!(exception.data.except(:with_alert)) if exception.respond_to?(:data)
+    data.merge!(exception: {
+                    class:   exception.class.name,
+                    message: exception.message
+                })
+
+    message(severity, subject, tags, data, backtrace)
+    exception.mark_logged
+  end
+
+
+  def self.log?(severity)
+    Settings.log.severity_level.nil? || enabled_severity?(severity, Settings.log.severity_level)
+  end
+
+  def self.enabled_severity?(message_severity, configured_severity)
+    message_index = SEVERITIES.index(message_severity)
+    configured_index = SEVERITIES.index(configured_severity.to_sym)
+    message_index.nil? || configured_index.nil? || message_index >= configured_index
+  end
+
+  def self.get_backtrace(backtrace)
+    locations = Rails.backtrace_cleaner.clean(backtrace || [])
+
+    locations.map do |location|
+      if location =~ /\A(.*):(\d+):\s*(?:in `(.*)')\z/
+        {
+            file:     $~[1],
+            line:     $~[2],
+            function: $~[3],
+        }
+      end
+    end.compact
+  end
+
+end

data/lib/tracer_client/server.rb

@@ -0,0 +1,36 @@
+require 'config'
+
+module Tracer
+  module Server
+
+    def self.log(notice_hash)
+      send("http://#{Settings.tracer.host}:#{Settings.tracer.port}/api/v3/projects/#{Settings.tracer.project}/notices?api_key=#{Settings.tracer.api_key}", notice_hash)
+    end
+
+
+    def self.log_changes(changes_hash)
+      Rails.logger.debug "Log change: #{changes_hash.inspect}"
+      send("http://#{Settings.tracer.host}:#{Settings.tracer.port}/api/v3/projects/#{Settings.tracer.project}/changes?api_key=#{Settings.tracer.api_key}", changes_hash)
+    end
+
+
+    private
+
+
+    def self.send(url, data)
+      uri = URI.parse(url)
+
+      Net::HTTP.start(uri.host, uri.port, read_timeout: 20) do |http|
+        http.request_post(uri.path + '?' + uri.query, JSON.dump(data), 'Content-Type' => 'text/xml; charset=utf-8') do |response|
+          return true if Net::HTTPNoContent === response
+          Rails.logger.error "Tracer request url: #{url}"
+          Rails.logger.error "Tracer response #{response.inspect}: #{response.body.inspect}"
+        end
+      end
+    rescue Exception => e
+      Rails.logger.error "Tracer request url: #{url}"
+      Rails.logger.error "Tracer exception #{e.inspect}: #{e.message}"
+    end
+
+  end
+end

data/lib/tracer_client/version.rb

@@ -0,0 +1,3 @@
+module TracerClient
+  VERSION = '0.1.0'
+end

data/tracer_client.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tracer_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'tracer_client'
+  spec.version       = TracerClient::VERSION
+  spec.authors       = ['Serge Galanin']
+  spec.email         = ['s.galanin@gmail.com']
+
+  spec.summary       = %q{Tracer API}
+  spec.description   = %q{Log errors and objects changes to Tracer.}
+  spec.homepage      = "https://github.com/galanin/tracer_client"
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'config', '~> 1.0'
+  spec.add_dependency 'rails', '~> 4.2'
+  spec.add_dependency 'sucker_punch', '~> 1.5'
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: tracer_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Serge Galanin
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: sucker_punch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Log errors and objects changes to Tracer.
+email:
+- s.galanin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/.name"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/tracer_client.rb
+- lib/tracer_client/changes.rb
+- lib/tracer_client/client.rb
+- lib/tracer_client/errors/api_error.rb
+- lib/tracer_client/errors/api_error_alert.rb
+- lib/tracer_client/errors/api_error_log.rb
+- lib/tracer_client/errors/api_request_failure.rb
+- lib/tracer_client/errors/api_request_failure_alert.rb
+- lib/tracer_client/errors/api_request_failure_log.rb
+- lib/tracer_client/errors/application_error.rb
+- lib/tracer_client/errors/logic_error.rb
+- lib/tracer_client/errors/logic_error_alert.rb
+- lib/tracer_client/errors/logic_error_log.rb
+- lib/tracer_client/log.rb
+- lib/tracer_client/server.rb
+- lib/tracer_client/version.rb
+- tracer_client.gemspec
+homepage: https://github.com/galanin/tracer_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Tracer API
+test_files: []