transaction_logger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 544d8e3034117695aa67e4d1fa207bb87e060dcf
+  data.tar.gz: bb1e5adbb2abfa94408b9c91fe5e401ec742affb
+SHA512:
+  metadata.gz: 18e1641a904647a7385544cf2077d38e547d876b5a517a858f685d711e43bcf6b76db33aabb41089bec3c27f0a7c29b89193c061914cf3c05da85bb35877d98d
+  data.tar.gz: d58c1a65794727de53cf7e03fd94acfc3a75c9f2f38f047e0fd9a3cff3bcc45ab5229923efdf1d3f4b2a04988c5ccd7415e83dbf573a9c164f5f208732c1e18e

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.yardopts

@@ -0,0 +1,10 @@
+--title "Transaction Logger (by Blinkist)"
+--charset utf-8
+--no-private
+--hide-void-return
+
+--markup-provider redcarpet
+--markup markdown
+
+lib/**/*.rb
+README.md

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Blinkist
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sebastian Schleicher
+
+MIT License
+
+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,108 @@
+# Blinkist TransactionLogger
+[ ![Codeship Status for blinkist/transaction_logger](https://codeship.com/projects/fb9745c0-edc7-0132-b6b1-1efd3f886df2/status?branch=master)](https://codeship.com/projects/84119) [![Code Climate](https://codeclimate.com/github/blinkist/transaction_logger/badges/gpa.svg)](https://codeclimate.com/github/blinkist/transaction_logger)
+
+Business Transactions Logger for Ruby that compiles contextual logging information and can send it to a configured logging service such as Logger or Loggly in a nested hash.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "transaction_logger"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install transaction_logger
+
+## Output
+
+Given a root transaction, the TransactionLogger is expected to print out every log that occurred under this root transaction, and each sub-transaction's local information.
+
+When a transaction raises an error, it will log the *error message*, *error class*, and *10 lines* of the backtrace by default. This will be logged at the level of the transaction that raised the error.
+
+## Usage
+
+Configure the logger by calling TransactionLogger.logger, such as with Ruby's Logger:
+
+```ruby
+logger = Logger.new STDOUT # Ruby default logger setup
+TransactionLogger.logger = logger
+```
+
+Wrap a business transaction method with a TransactionLogger lambda:
+
+```ruby
+def some_method
+  TransactionLogger.start -> (t) do
+    # your code.
+  end
+end
+```
+
+From within this lambda, you may call upon t to add a custom name, context and log your messages, like so:
+
+```ruby
+t.name = "YourClass.some_method"
+t.context = { specific: "context: #{value}" }
+t.log "A message you want logged"
+```
+
+### Example
+
+Here is a transaction that raises an error:
+
+```ruby
+class ExampleClass
+  def some_method
+    TransactionLogger.start -> (t) do
+      t.name = "ExampleClass.some_method"
+      t.context = { some_id: 12 }
+
+      t.log "Trying something complex"
+      raise RuntimeError, "Error"
+
+      result
+      t.log "Success"
+    end
+  end
+end
+```
+
+The expected output is:
+
+```json
+{
+  "transaction_name": "ExampleClass.some_method",
+  "transaction_context": {
+    "some_id": 12
+  },
+  "transaction_duration": 0.112,
+  "transaction_history": [{
+    "transaction_info": "Trying something complex"
+    }, {
+      "transaction_error_message": "Error",
+      "transaction_error_class": "RuntimeError",
+      "transaction_error_backtrace": [
+        "example.rb:84:in `block in nested_method'",
+        ".../TransactionLogger_Example/transaction_logger.rb:26:in `call'",
+        ".../TransactionLogger_Example/transaction_logger.rb:26:in `run'",
+        ".../TransactionLogger_Example/transaction_logger.rb:111:in `start'",
+        "example.rb:79:in `nested_method'"
+      ]
+
+  }]
+}
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/blinkist/transaction_logger/fork )
+2. Create your feature branch (`git checkout -b feature/your_feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin feature/your_feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/transaction_logger/transaction.rb

@@ -0,0 +1,131 @@
+
+class TransactionLogger::Transaction
+  attr_reader :parent
+
+  attr_accessor :name
+  attr_accessor :context
+
+  # @param parent [TransactionLogger::Transaction] Parent of transaction
+  # @param lmbda [Proc] The surrounded block
+  #
+  def initialize(parent=nil, lmbda)
+    @parent = parent
+    @parent.log self if @parent
+
+    @lmbda = lmbda
+
+    @name = "undefined"
+    @context = {}
+    @log_queue = Array.new
+    @start = Time.now
+    @error_printed = nil
+  end
+
+  # @private
+  # Runs the lines of code from within the lambda. FOR INTERNAL USE ONLY.
+  #
+  def run
+    begin
+      result = @lmbda.call self
+    rescue => error
+
+      e_message_key = "#{TransactionLogger.log_prefix}error_message"
+      e_class_key = "#{TransactionLogger.log_prefix}error_class"
+      e_backtrace_key = "#{TransactionLogger.log_prefix}error_backtrace"
+
+      log({
+        e_message_key => error.message,
+        e_class_key => error.class.name,
+        e_backtrace_key => error.backtrace.take(5)
+      })
+
+      failure error, self
+    else
+      success
+    end
+
+    result
+  end
+
+  # Pushes a message into the log queue. Logs are stored in order
+  #   of time logged. Note that this method will not output a log, but just
+  #   stores it in the queue to be outputted if an error is raised in a
+  #   transaction.
+  #
+  # @param message [#to_s] Any String or Object that responds to to_s
+  #   that you want to be stored in the log queue.
+  #
+  def log(message)
+    if message.is_a? String
+      message_key = "#{TransactionLogger.log_prefix}info"
+      message = { message_key => message }
+      @log_queue.push message
+    else
+      @log_queue.push message
+    end
+  end
+
+  # @private
+  # Logs the error and raises error to the parent process
+  def failure(error, transaction)
+    calc_duration
+
+    if @parent
+      @parent.failure error, transaction
+    else
+      unless @error_printed
+        print_transactions
+        @error_printed = true
+      end
+
+      raise error
+    end
+  end
+
+  # @private
+  # Converts a Transaction and it's children into a single nested hash
+  def to_hash
+    name_key = "#{TransactionLogger.log_prefix}name"
+    context_key = "#{TransactionLogger.log_prefix}context"
+    duration_key = "#{TransactionLogger.log_prefix}duration"
+    history_key = "#{TransactionLogger.log_prefix}history"
+
+    output = {
+      name_key => @name,
+      context_key => @context,
+      duration_key => @duration,
+      history_key => []
+    }
+
+    @log_queue.each {|entry|
+      if entry.is_a? TransactionLogger::Transaction
+        output[history_key] << entry.to_hash
+      elsif entry.is_a? Hash
+        output[history_key] << entry
+      else
+        output[history_key] << entry
+      end
+    }
+
+    output
+  end
+
+
+  private
+
+  # Calculates the duration upon the success of a transaction
+  def success
+    calc_duration
+  end
+
+  # Calculates the number of milliseconds that the Transaction has taken
+  def calc_duration
+    @duration = (Time.now - @start) * 1000.0
+  end
+
+  # Sends the transaction context and log to an instance of logger
+  def print_transactions(transaction=nil)
+    TransactionLogger.logger.error to_hash
+  end
+
+end

data/lib/transaction_logger/version.rb

@@ -0,0 +1,3 @@
+class TransactionLogger
+  VERSION = "0.0.1"
+end

data/lib/transaction_logger.rb

@@ -0,0 +1,85 @@
+require "transaction_logger/version"
+require "transaction_logger/transaction"
+
+class TransactionLogger
+
+  @@prefix = ""
+  @@current_transactions = {}
+
+  # Marks the beginning of a "Transaction lambda," which will log an error if the
+  #   containing code raises an error. A lambda instance variable let's you call
+  #   the .log method and access the ".name" and ".context" variables. The start
+  #   method must take a lambda as an argument.
+  #
+  #   Whatever the outer method is, if a value is returned within the Transaction
+  #   lambda it will be returned to the outer method as well.
+  #
+  #   The start method does not catch errors, so if an error is raised, it will simply
+  #   envoke a logging message to be outputted and then raise the error.
+  #
+  #   This also checks which thread is envoking the method in order to make sure the
+  #   logs are thread-safe.
+  #
+  # @param lmbda [Proc]
+  #
+  def self.start(lmbda)
+
+    active_transaction = get_active_transaction
+
+    transaction = TransactionLogger::Transaction.new active_transaction, lmbda
+    active_transaction = transaction
+
+    set_active_transaction active_transaction
+
+    begin
+      transaction.run
+    rescue Exception => e
+      raise e
+    ensure
+      set_active_transaction transaction.parent
+    end
+  end
+
+  # Sets the TransactionLogger's output to a specific instance of Logger.
+  #
+  # @param logger [Logger] Any instace of ruby Logger
+  #
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  # Sets the TransactionLogger's output to a new instance of Logger
+  #
+  def self.logger
+    @@logger ||= Logger.new(STDOUT)
+  end
+
+  #
+  #
+  def self.log_prefix=(prefix)
+    @@prefix = "#{prefix}"
+  end
+
+  def self.log_prefix
+    @@prefix
+  end
+
+  # @private
+  # Returns the current parent of a thread of Transactions.
+  #
+  # @return [TransactionLogger::Transaction] The current parent given a Thread
+  #
+  def self.get_active_transaction
+    if @@current_transactions.has_key?(Thread.current.object_id)
+      @@current_transactions[Thread.current.object_id]
+    end
+  end
+
+  # @private
+  # Sets the current parent of a thread of Transactions.
+  #
+  def self.set_active_transaction(transaction)
+    @@current_transactions[Thread.current.object_id] = transaction
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require "transaction_logger"
+
+require "support/debugging"
+
+RSpec.configure do |config|
+  config.order = "random"
+end

data/spec/support/debugging.rb

@@ -0,0 +1 @@
+require "byebug"

data/spec/transaction_logger_spec.rb

@@ -0,0 +1,248 @@
+require "spec_helper"
+require "logger"
+
+describe TransactionLogger do
+
+  let (:test_lmbda) {
+    -> (t) do
+    end
+  }
+
+  subject { TransactionLogger::Transaction.new nil, test_lmbda }
+
+  it "initializes with a nil parent" do
+    expect(subject.parent).to be_nil
+  end
+
+  it "responds to .start" do
+    expect(described_class).to receive(:start)
+    described_class.start -> (t) do end
+  end
+
+  context "when there is a parent" do
+
+    let (:test_parent) { subject }
+    let (:child) { child = TransactionLogger::Transaction.new test_parent, test_lmbda }
+    let (:test_parent_log_queue) { test_parent.instance_variable_get(:@log_queue) }
+
+    it "has a parent" do
+      expect(child).to have_attributes(:parent => test_parent)
+    end
+
+    it "places itself into the log of the parent" do
+      expect(test_parent_log_queue).to include(child)
+    end
+
+    context "when there is an error" do
+
+      it "raises the error to the parent" do
+
+      end
+
+    end
+
+  end
+
+  context "when in 3-level nested transactions" do
+    it "raises an error" do
+      expect {
+        described_class.start -> (t) do
+          t.context = {user_id: 01, information: "contextual info"}
+          t.log "First Message"
+
+          described_class.start -> (t2) do
+            t2.context = {user_id: 01, information: "contextual info"}
+            t2.log "Second Message"
+            t2.log "Third Message"
+
+          end
+
+          t.log "Fourth Message"
+
+          described_class.start -> (t3) do
+            t3.context = {user_id: 01, information: "contextual info"}
+            t3.log "Fifth Message"
+
+            described_class.start -> (t4) do
+              t4.context = {user_id: 01, information: "contextual info"}
+              t4.log "Sixth Message"
+              t4.log "Seventh Message"
+
+              fail RuntimeError, "test error"
+            end
+
+            t3.log "Eighth Message"
+          end
+
+        end
+      }.to raise_error RuntimeError
+    end
+  end
+
+  describe ".start" do
+    let (:test_lmbda) {
+      described_class.start -> (t) do
+        t.log ""
+      end
+    }
+  end
+
+  describe ".log_prefix" do
+
+    context "when there is no prefix" do
+      it "does not change the output" do
+        expect(subject.to_hash).to include("name" => "undefined")
+      end
+    end
+
+    context "when a prefix is defined" do
+      let (:prefix) { "bta_" }
+
+      before :example do
+        described_class.log_prefix = prefix
+      end
+
+      after :example do
+        described_class.log_prefix = ""
+      end
+
+      it "adds the prefix to every key" do
+        expect(subject.to_hash).to include("bta_name" => "undefined")
+      end
+    end
+
+  end
+
+  describe "#run" do
+
+    context "when no exception is raised" do
+
+      let (:test_lmbda) {
+        -> (t) do
+          "result"
+        end
+      }
+
+      let (:result) { subject.run }
+
+      it "returns lmda" do
+        expect(result).to eq "result"
+      end
+
+    end
+
+    context "when an exception is raised" do
+
+      let (:test_lmbda) {
+        -> (t) do
+          fail RuntimeError, "test error"
+        end
+      }
+
+      let (:result) { subject.run }
+
+      it "raises an exception" do
+        expect{result}.to raise_error "test error"
+      end
+
+      it "calls failure" do
+        expect(subject).to receive(:failure)
+        result
+      end
+
+    end
+
+  end
+
+  # Try to think of ways to refactor this
+  #   given that I can test certain specific behaviors
+  #   first, and then use those tests to know the bigger
+  #   picture is working...
+  describe "Logger" do
+
+    subject {
+      Logger.new STDOUT
+    }
+
+    before :each do
+      described_class.logger = subject
+    end
+
+    context "when there is one transaction" do
+
+      it "recieves nothing" do
+        expect(subject).to_not receive(:error)
+
+        described_class.start -> (t) do
+          t.context = {user_id: 01, information: "contextual info"}
+          t.log "First Message"
+        end
+      end
+
+      it "recieves error if an exception occurs" do
+        expect(subject).to receive(:error)
+        expect {
+          described_class.start -> (t) do
+            t.context = {user_id: 01, information: "contextual info"}
+            t.log "First Message"
+            fail RuntimeError, "test error"
+          end
+        }.to raise_error(RuntimeError)
+      end
+
+    end
+
+    context "when there is a nested transaction with two levels" do
+
+      it "recieves error if an exception occurs" do
+        expect(subject).to receive(:error) do |options|
+          expect(options["history"]).to include( {"info" => "First Message"} )
+          expect(options["history"].last["history"]).to include({"info" => "Second Message"})
+          expect(options["history"].last["history"].last["error_message"]).to eq("test error")
+          expect(options["history"].last["history"].last["error_class"]).to eq("RuntimeError")
+        end
+
+        expect {
+          described_class.start -> (t) do
+            t.context = {user_id: 01, information: "contextual info"}
+            t.log "First Message"
+            described_class.start -> (t2) do
+              t2.log "Second Message"
+              fail RuntimeError, "test error"
+            end
+          end
+        }.to raise_error RuntimeError
+      end
+
+    end
+
+    context "when there are two nested transactions, two-levels deep" do
+
+      it "recieves error if an exception occurs" do
+
+        expect(subject).to receive("error") do |options|
+          expect(options["history"].first["history"]).to include({"info" => "First Message"})
+          expect(options["history"].last["history"]).to include({"info" => "Second Message"})
+          expect(options["history"].last["history"].last["error_message"]).to eq("test error")
+          expect(options["history"].last["history"].last["error_class"]).to eq("RuntimeError")
+        end
+
+        expect {
+          described_class.start -> (t) do
+            t.context = {user_id: 01, information: "contextual info"}
+            described_class.start -> (t2) do
+              t2.log "First Message"
+            end
+            described_class.start -> (t2) do
+              t2.log "Second Message"
+              fail RuntimeError, "test error"
+            end
+          end
+        }.to raise_error RuntimeError
+      end
+
+    end
+
+  end
+
+end

data/transaction_logger.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'transaction_logger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "transaction_logger"
+  spec.version       = TransactionLogger::VERSION
+  spec.authors       = ["John Donner", "Sebastian Schleicher"]
+  spec.email         = ["johnbdonner@gmail.com", "sebastian.julius@gmail.com"]
+  spec.summary       = %q{Contextual Business Transaction Logger for Ruby}
+  spec.description   = %q{A logger that silently collects information in the \
+                          background and when an error is raised, logs a hash either \
+                          out to the System or pushes the log to a service such as \
+                          Loggly. The log hash contains information such as the \
+                          backtrace, any logs from calling classes and methods, \
+                          and configurable contextual information.}
+  spec.homepage      = "https://github.com/blinkist/transaction_logger"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = Gem::Requirement.new ">= 2.1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "redcarpet"
+  spec.add_development_dependency "github-markdown"
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: transaction_logger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Donner
+- Sebastian Schleicher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: github-markdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  A logger that silently collects information in the \
+                            background and when an error is raised, logs a hash either \
+                            out to the System or pushes the log to a service such as \
+                            Loggly. The log hash contains information such as the \
+                            backtrace, any logs from calling classes and methods, \
+                            and configurable contextual information.
+email:
+- johnbdonner@gmail.com
+- sebastian.julius@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/transaction_logger.rb
+- lib/transaction_logger/transaction.rb
+- lib/transaction_logger/version.rb
+- spec/spec_helper.rb
+- spec/support/debugging.rb
+- spec/transaction_logger_spec.rb
+- transaction_logger.gemspec
+homepage: https://github.com/blinkist/transaction_logger
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Contextual Business Transaction Logger for Ruby
+test_files:
+- spec/spec_helper.rb
+- spec/support/debugging.rb
+- spec/transaction_logger_spec.rb
+has_rdoc: