quickbase_logger 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e71162078aadd4bff3657c696a5d96abc24f539
+  data.tar.gz: dc323756fda5cc2604587a0742b702eae3592fe2
+SHA512:
+  metadata.gz: 648f1962ee519233a3bfa08d19bd9063fc5b692e626a0a26c57a11c34e975f1f81ca7d04222eac962cd40a3cb59c25f905e5451e4ca978266dca005545005f79
+  data.tar.gz: f8deae68d77bb5a83fb3a459e387840564681568008a23034444b19ff00bd87f97f2e0f7bc53d1544db3e8e5a8e46d4dd542889d077c029dca3e601c2b176827

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Cullen Jett
+
+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,143 @@
+# QuickbaseLogger
+
+"QuickbaseLogger offers a configurable way to use the Intuit QuickBase platform as a way to log Ruby script information."
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'quickbase_logger'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quickbase_logger
+
+## What is it?
+QuickbaseLogger offers a way to wrap your code in a begin/rescue block that will create QuickBase records after the block is finished executing. In addition, it will create a standard ruby Logger instance and write logs to a .log file. It offers a similar API as the standard ruby Logger (i.e. #info, #warn, #error).
+
+
+## Usage
+
+### Configuration
+QuickbaseLogger relies on a certain architechture for the QuickBase application you write logs to -- as of version 0.0.1 you must have **two** tables, a parent Scripts table and a child table for the Script Logs (obviously you can name them whatever you want, it's only the parent-child relationship that's important). In the Script Logs child table there are a handful of fields that QuickbaseLogger will write to (i.e. you need these fields in your Script Logs child table):
+- 'Start' -- A DateTime field that defines when the script started running.
+- 'End' -- A DateTime field that defines when the script finished running.
+- 'Logs' -- A Multi-line Text field that will capture any .info(message) calls and the backtrace for exceptions.
+- 'Status' -- A Text field that will either be populated with 'Success' or 'Failure' based on if any exceptions are thrown during the script's execution.
+- 'Related Script' -- The [Record ID#] of the parent script.
+
+**Note that the names you give the fields in the .define_fields configuration block need to match the names above (the lowercase version, of course). See below for an example.**
+
+QuickbaseLogger is built on top of the wonderful [QuickbaseRecord](https://github.com/cullenjett/quickbase_record) gem, and follows a similiar pattern for configuration.
+
+```ruby
+  # config/initializers/quickbase_logger.rb
+
+  QuickbaseLogger.configure do |config|
+    # same config as QuickbaseRecord
+    config.realm = "quickbase_app_realm_name"
+    config.username = "valid_username"
+    config.password = "valid_password"
+    config.token = "quickbase_app_token_if_applicable"
+
+    # new config options specific to QuickbaseLogger
+    # .logger_path -- the path to where text logs will write to.
+    # NOTE: this is required as of version 0.0.1 (it will default to /log, but your app may not follow that pattern and this could cause some headache if not defined here)
+    config.logger_path = "/log"
+
+    # .define_fields -- just a proxy for the method of the same name in QuickbaseRecord.
+    # This creates the map of field IDs to field names.
+    # NOTE: with the exception of :id, your field names (i.e. ':start', ':end', etc.) must match those below.
+    # (a :primary_key field is also required)
+    config.define_fields do |t|
+      t.dbid 'bkd86zn87'
+      t.number :id, 3, :primary_key, :read_only
+      t.date :start, 6
+      t.date :end, 7
+      t.string :log, 8
+      t.string :status, 9
+      t.number :related_script, 10
+    end
+  end
+```
+
+### Methods and API
+Using QuickbaseLogger is as simple as instantiating an instance of QuickbaseLogger::Logger and wrapping any code you want logged to your Script Logs QuickBase table in the #log_to_quickbase method on that instance.
+
+QuickbaseLogger::Logger.new accepts a :related_script argument that is the [Record ID#] of the parent Script record, and an optional :file_name argument for the name of the text log file. If no :file_name argument is given it will default to "quickbase_logger_default"
+
+```ruby
+  qb_logger = QuickbaseLogger::Logger.new(related_script: 123, file_name: 'my_awesome_log_file')
+```
+
+The instance returned from QuickbaseLogger::Logger.new has a method named #log_to_quickbase that accepts a block of code you want to capture in you logs. While inside the scope of the #log_to_quickbase method, you have access to #info(message), #warn(message), and #error(message) methods on the logger instance that simply log the given message to the :log field on the Script Logs table in QuickBase as well as the text logger. Each of these methods will capture the time of the log automatically.
+
+```ruby
+  qb_logger = QuickbaseLogger::Logger.new(related_script: 123, file_name: 'my_awesome_log_file')
+  qb_logger.log_to_quickbase do
+    # any code within the scope of this block is fair game
+  end
+```
+
+Note that the logs are automatically prepended with "START" and appended with "END", so you don't need to denote a start and end of the script's current run.
+
+
+```ruby
+
+class SomeAwesomeScript
+  def self.perform
+    qb_logger = QuickbaseLogger::Logger.new(related_script: 123, file_name: 'some_awesome_script')
+
+    # Any exceptions thrown in the scope of this block
+    # will be rescued and sent to QuickBase.
+    qb_logger.log_to_quickbase do
+      # qb_logger.info("START -- #{Time.now}") -- don't do this, it's automatically done for you.
+      open_orders = Order.where(status: 'open')
+      qb_logger.info("found #{open_orders.length} open orders.")
+
+      open_orders.each do |order|
+        order.close
+      end
+    end
+  end
+end
+```
+
+Here's how the #log_to_quickbase method is structured (for your reference):
+
+```ruby
+  def log_to_quickbase
+    begin
+      yield
+      log_success_to_text_file
+      log_success_to_quickbase
+    rescue => err
+      log_failure_to_text_file(err)
+      log_failure_to_quickbase(err)
+      raise err
+    end
+  end
+```
+
+### The QuickBase Records
+Here's an example record for a log for a script that ran without throwing any exceptions (the 'Error' in the log is from a call to #error(message), not a ruby exception):
+
+![successful_record_example](images/without_errors.png)
+
+And one where an error occurred (this is from a manually raised StandardError, hence the 'YOU BLEW UP THE CODE' message. Typically this will be one of the many ruby execption messages you're familiar with):
+
+![unsuccessful_record_example](images/with_errors.png)
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/quickbase_logger/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/lib/quickbase_logger.rb

@@ -0,0 +1,27 @@
+require "quickbase_record"
+require "quickbase_logger/version"
+require "quickbase_logger/logger"
+require "quickbase_logger/configuration"
+
+module QuickbaseLogger
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+
+    QuickbaseRecord.configure do |config|
+      config.realm = configuration.realm
+      config.username = configuration.username
+      config.password = configuration.password
+      config.token = configuration.token
+    end
+
+    Logger.define_fields(&configuration.fields_definition)
+  end
+end

data/lib/quickbase_logger/configuration.rb

@@ -0,0 +1,12 @@
+module QuickbaseLogger
+  class Configuration
+    attr_accessor :realm, :username, :password, :token, :logger_path, :fields_definition
+
+    def initialize
+    end
+
+    def define_fields(&block)
+      self.fields_definition = block
+    end
+  end
+end

data/lib/quickbase_logger/logger.rb

@@ -0,0 +1,106 @@
+module QuickbaseLogger
+  class Logger
+    include QuickbaseRecord::Model
+
+    attr_accessor :text_logger
+
+    def initialize(options={})
+      raise ArgumentError.new("QuickbaseLogger::Logger.new must receive a :related_script argument.") unless options[:related_script]
+
+      @log = []
+      @start = "#{formatted_date} #{formatted_time}"
+
+      file_name = options.fetch(:file_name, 'quickbase_logger_default')
+      @text_logger = ::Logger.new("#{formatted_logger_path}#{file_name}.log", "monthly") # standard ruby Logger instance
+      super
+    end
+
+    def log_to_quickbase
+      raise ArgumentError.new("#log_to_quickbase() must be given a block. Code run inside that block will be logged to the QuickBase application.") unless block_given?
+
+      begin
+        yield
+        log_success_to_text_file
+        log_success_to_quickbase
+      rescue => err
+        log_failure_to_text_file(err)
+        log_failure_to_quickbase(err)
+        raise err
+      end
+    end
+
+    def info(message)
+      log << "Info [#{formatted_time}]: #{message}"
+    end
+
+    def warn(message)
+      log << "Warn [#{formatted_time}]: #{message}"
+    end
+
+    def error(message)
+      log << "Error [#{formatted_time}]: #{message}"
+    end
+
+    private
+
+    def log_success_to_text_file
+      joined_logs = self.log.join("\n")
+      text_logger.info("LOGS:\n#{joined_logs}")
+      text_logger.info("END")
+    end
+
+    def log_failure_to_text_file(err)
+      joined_logs = self.log.join("\n")
+      text_logger.info("logs:\n#{joined_logs}")
+
+      text_logger.error("ERROR: #{err}")
+      text_logger.error("BACKTRACE:\n\t#{err.backtrace.slice(0, 10).join("\n\t")}")
+    end
+
+    def log_success_to_quickbase
+      self.status = "Success"
+      self.end = "#{formatted_date} #{formatted_time}"
+      self.log = self.log.join("\n")
+
+      begin
+        save
+      rescue StandardError => err
+        text_logger.error("-- COULD NOT WRITE SUCCESS TO QUICKBASE --")
+        text_logger.error(err)
+        text_logger.error("BACKTRACE:\n\t#{err.backtrace.slice(0, 10).join("\n\t")}")
+        raise err
+      end
+    end
+
+    def log_failure_to_quickbase(err)
+      self.end = "#{formatted_date} #{formatted_time}"
+      self.status = "Failure"
+
+      self.log = self.log.join("\n")
+      self.log << "\nERROR: #{err} \n"
+      self.log << "BACKTRACE:\n\t#{err.backtrace.slice(0, 10).join("\n\t")}"
+
+      begin
+        save
+      rescue StandardError => err
+        text_logger.error("-- COULD NOT WRITE FAILURE TO QUICKBASE --")
+        text_logger.error(err)
+        text_logger.error("BACKTRACE:\n\t#{err.backtrace.slice(0, 10).join("\n\t")}")
+        raise err
+      end
+    end
+
+    def formatted_date
+      DateTime.now.strftime("%m/%d/%Y").strip
+    end
+
+    def formatted_time
+      DateTime.now.strftime("%l:%M:%S %p").strip
+    end
+
+    def formatted_logger_path
+      path = QuickbaseLogger.configuration.logger_path || "/log"
+      path[-1] =~ /\// ? path : "#{path}/"
+    end
+  end
+end

data/lib/quickbase_logger/version.rb

@@ -0,0 +1,3 @@
+module QuickbaseLogger
+  VERSION = "0.0.1"
+end

data/quickbase_logger.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'quickbase_logger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "quickbase_logger"
+  spec.version       = QuickbaseLogger::VERSION
+  spec.authors       = ["Cullen Jett"]
+  spec.email         = ["cullenjett@gmail.com"]
+  spec.summary       = "Use Quickbase tables as a logging platform"
+  spec.description   = "QuickbaseLogger offers a configurable way to use the Intuit QuickBase platform as a way to log Ruby script information."
+  spec.homepage      = "https://github.com/cullenjett/quickbase_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.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_runtime_dependency "quickbase_record", ">= 0.4.5"
+end

data/spec/quickbase_logger_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+require 'yaml'
+
+creds = YAML.load_file("spec/config.yml")
+
+RSpec.describe QuickbaseLogger do
+  describe '.configure' do
+    it "passes it's block to QuickbaseRecord.configure()" do
+      expect(QuickbaseRecord).to receive(:configure)
+      QuickbaseLogger.configure do |config|
+        config.realm = "ais"
+        config.username = creds["username"]
+        config.password = creds["password"]
+      end
+    end
+  end
+end
+
+
+RSpec.describe QuickbaseLogger::Logger do
+  describe '.initialize' do
+    it "defines a parent script that all log records will be related to" do
+      logger = QuickbaseLogger::Logger.new(related_script: 123)
+      expect(logger.related_script).to eq(123)
+    end
+  end
+
+  describe '#log_to_quickbase' do
+    it "calls #save to create a new record in QuickBase" do
+      qb_logger = QuickbaseLogger::Logger.new(related_script: 1)
+
+      expect(qb_logger).to receive(:save)
+
+      qb_logger.log_to_quickbase do
+        qb_logger.info('Hello, world!')
+        qb_logger.warn('Danger ahead...')
+        qb_logger.error('OH NO!!!')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'quickbase_record'
+require 'quickbase_logger'
+require 'yaml'
+
+creds = YAML.load_file("spec/config.yml")
+
+QuickbaseLogger.configure do |config|
+  config.realm = "ais"
+  config.username = creds["username"]
+  config.password = creds["password"]
+
+  config.logger_path = "./spec/log"
+  config.define_fields do |t|
+    t.dbid 'bkd86zn87'
+    t.number :id, 3, :primary_key, :read_only
+    t.date :start, 6
+    t.date :end, 7
+    t.string :log, 8
+    t.string :status, 9
+    t.number :related_script, 10
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: quickbase_logger
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Cullen Jett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-13 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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: quickbase_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.5
+description: QuickbaseLogger offers a configurable way to use the Intuit QuickBase
+  platform as a way to log Ruby script information.
+email:
+- cullenjett@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- images/with_errors.png
+- images/without_errors.png
+- lib/quickbase_logger.rb
+- lib/quickbase_logger/configuration.rb
+- lib/quickbase_logger/logger.rb
+- lib/quickbase_logger/version.rb
+- quickbase_logger.gemspec
+- spec/log/quickbase_logger_default.log
+- spec/quickbase_logger_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/cullenjett/quickbase_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: '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: Use Quickbase tables as a logging platform
+test_files:
+- spec/log/quickbase_logger_default.log
+- spec/quickbase_logger_spec.rb
+- spec/spec_helper.rb