lonline 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e7881beef7a86ecb8796452640f609951435a563
+  data.tar.gz: 4b9078505a7baf1d203880c3d7ecacc363785b7e
+SHA512:
+  metadata.gz: 1eb613295148a2b31a104bb3afa4f7745a300d649be91989fa3182fac8a8f11a4963d3c0a31be17a33cb2319050dbfa7a7a87b1e5df1e57c44dd05e0f2bb956f
+  data.tar.gz: 3c3a7d8d13dec976fce98c628552a50cf3ba9be8fca96d3d4f2f0e01958aa9f0f13206dc204134a9b5fb7dc6ba8e722d95542ab8fd51026cc59fa18231537475

data/lib/generators/lonline_generator.rb

@@ -0,0 +1,114 @@
+# This generator creates the files to setup lonline
+# Will create an initializer to load lonline settings
+# Will create a setting file as a template to put information about
+# Dynamicloud credentials and more settings.
+class LonlineGenerator < Rails::Generators::Base
+  def create_initializer_file
+    create_file 'config/initializers/lonline.rb',
+                "Lonline::SETUP.load('config/lonline.yml', Rails.env)
+# The line below sets the logger you're using in your program, every call of lonline will execute the same method in your logger
+# For example:
+# Lonline.log.fatal('The app has crashed and its state is unavailable') # This call will execute the following method in your logger
+# logger.fatal('The app has crashed and its state is unavailable') # If this method is unavailable, lonline
+# will catch the error without any feedback to you.
+# If you don't need this behaviour, remove this line.
+Lonline::SETUP.logger = Rails.logger"
+
+    create_file 'config/lonline.yml',
+                "test: &default
+  # Credentials for REST APIs
+  # Go to https://www.dynamicloud.org/manage and get the API keys available in your profile
+  # If you don't have an account in Dynamicloud, visit https://www.dynamicloud.org/signupform
+  # You can easily use a social network to sign up
+  csk: Enter your Client_Secret_Key
+  aci: Enter your API_Client_Id
+  # This is the model identifier for test and development environment
+  # The model contains the structure to store logs into the cloud
+  # For more information about models in Dynamicloud visit https://www.dynamicloud.org/documents/mfdoc
+  model_identifier: 0
+  # async = true is the best choice to avoid impact in your app's execution.
+  # If you want to wait for every request, set async: false
+  async: false
+  # Shows every warning like rejected request from Dynamicloud and other warnings in lonline
+  warning: true
+  # Send the backtrace (the ordered method calls) of the log.  If you want to avoid this set to false
+  backtrace: true
+  # This tag indicates the level of lonline
+  # The following table is an explanation of levels in Lonline (Descriptions from the great Log4j library):
+  # ------------------------------------------------------------------------------------------------------------
+  # | Level      | Activated levels           | Description                                                    |
+  # ------------------------------------------------------------------------------------------------------------
+  # | fatal      | Fatal                      | Designates very severe error events that will presumably lead  |
+  # |            |                            | the application to abort.                                      |
+  # ------------------------------------------------------------------------------------------------------------
+  # | error      | Fatal, Error               | Designates error events that might still allow the application |
+  # |            |                            | to continue running.                                           |
+  # ------------------------------------------------------------------------------------------------------------
+  # | warn       | Fatal, Error, Warn         | Designates potentially harmful situations.                     |
+  # ------------------------------------------------------------------------------------------------------------
+  # | info       | Fatal, Error, Warn, Info   | Designates informational messages that highlight the progress  |
+  # |            |                            | of the application at coarse-grained level.                    |
+  # ------------------------------------------------------------------------------------------------------------
+  # | debug      | Fatal, Error, Info, Warn,  | Designates fine-grained informational events that are most     |
+  # |            | Debug                      | useful to debug an application.                                |
+  # ------------------------------------------------------------------------------------------------------------
+  # | trace      | All levels                 | Traces the code execution between methods, lines, etc.         |
+  # ------------------------------------------------------------------------------------------------------------
+  # | off        | None                       | The highest possible rank and is intended to turn off logging. |
+  # ------------------------------------------------------------------------------------------------------------
+  level: trace
+  # report_limit indicates how many records lonline will execute to fetch data from Dynamicloud.
+  # If you need to increase this value, please think about the available requests per month in your account.
+  # Dynamicloud uses a limit of records per request, at this time the max records per request is 20.  So,
+  # report_limit=100 are 5 request.
+  report_limit: 100
+development:
+  <<: *default
+production:
+  <<: *default
+  # Credentials for REST APIs in production environment
+  # Go to https://www.dynamicloud.org/manage and get the API keys available in your profile
+  # If you don't have an account in Dynamicloud, visit https://www.dynamicloud.org/signupform
+  # You can easily use a social network to sign up
+  csk: Enter your Client_Secret_Key
+  aci: Enter your API_Client_Id
+  # This is the model id for production environment
+  model_identifier: 0
+  # async = true is the best choice to avoid impact in your app's execution.
+  # If you want to wait for every request, set async: false
+  async: true
+  # Shows every warning like rejected request from Dynamicloud
+  warning: false
+  # Send the backtrace of the log.  If you want to avoid this set to false
+  backtrace: true
+  # This tag indicates the level of lonline
+  # The following table is an explanation of levels in Lonline (Descriptions from the great Log4j library):
+  # ------------------------------------------------------------------------------------------------------------
+  # | Level      | Activated levels           | Description                                                    |
+  # ------------------------------------------------------------------------------------------------------------
+  # | fatal      | Fatal                      | Designates very severe error events that will presumably lead  |
+  # |            |                            | the application to abort.                                      |
+  # ------------------------------------------------------------------------------------------------------------
+  # | error      | Fatal, Error               | Designates error events that might still allow the application |
+  # |            |                            | to continue running.                                           |
+  # ------------------------------------------------------------------------------------------------------------
+  # | warn       | Fatal, Error, Warn         | Designates potentially harmful situations.                     |
+  # ------------------------------------------------------------------------------------------------------------
+  # | info       | Fatal, Error, Warn, Info   | Designates informational messages that highlight the progress  |
+  # |            |                            | of the application at coarse-grained level.                    |
+  # ------------------------------------------------------------------------------------------------------------
+  # | debug      | Fatal, Error, Info, Warn   | Designates fine-grained informational events that are most     |
+  # |            | Debug                      | useful to debug an application.                                |
+  # ------------------------------------------------------------------------------------------------------------
+  # | trace      | All levels                 | Traces the code execution between methods, lines, etc.         |
+  # ------------------------------------------------------------------------------------------------------------
+  # | off        | None                       | The highest possible rank and is intended to turn off logging. |
+  # ------------------------------------------------------------------------------------------------------------
+  level: error
+  # report_limit indicates how many records lonline will execute to fetch data from Dynamicloud.
+  # If you need to increase this value, please think about the available requests per month in your account.
+  # Dynamicloud uses a limit of records per request, at this time the max records per request is 20.  So,
+  # report_limit=100 are 5 request (if your report execution has at least 100 logs).
+  report_limit: 100"
+  end
+end

data/lib/lonline.rb

@@ -0,0 +1,248 @@
+#Copyright (c) 2016 Dynamicloud
+#
+#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.
+#
+#Lonline module provides the main functions to log and send data to the cloud
+#
+#The uses of Lonline are the followings:
+#
+#Lonline.log.trace('Calling method Y')
+#Lonline.log.debug('Creating new object')
+#Lonline.log.info('Process has finished')
+#Lonline.log.warn('It could'n create this object, the process will try later.)
+#Lonline.log.error('Unable to load setting file')
+#Lonline.log.fatal('The app has crashed and its state is unavailable')
+#
+#If you active warning in lonline, every rejected request from Dynamicloud will be printed in stdout.
+#
+#Lonline will verify the level of logging to avoid unnecessary request to Dynamicloud
+#
+#Important: Dynamicloud offers in its free version 5.000 monthly requests and 500Mb of disk space.
+#
+#Dynamicloud is a powerful service that offers a dynamic way to add attributes to your business.
+#To send additional data, you need to pass a hash with the additional attributes (Fields)
+#
+#For example:
+#
+#Lonline.log.fatal('Testing trace', {:module => 'Logging from financial module.'})
+#
+#The above call, indicates to lonline that you need to send an additional field called 'module'.
+#
+#For further information, visit lonline's repository on https://github.com/dynamicloud/lonline_for_ruby
+
+require 'dynamic_api'
+require 'yaml'
+
+module Lonline
+  # The available levels in lonline.
+  LEVELS = {
+      :false => 7,
+      :off => 7,
+      :fatal => 6,
+      :error => 5,
+      :warn => 4,
+      :info => 3,
+      :debug => 2,
+      :trace => 1
+  }
+
+  # This class provides the four methods to log and send data to the cloud.
+  class Log
+    attr_accessor :logger
+
+    def initialize
+      @logger = nil
+    end
+
+    # The DEBUG Level designates fine-grained informational events that are most useful to debug an application.
+    def debug(text, additional_data = {})
+      begin
+        @logger.debug(text)
+      rescue
+        #ignore
+      ensure
+        send_log(:debug, text, additional_data)
+      end
+    end
+
+    # The INFO level designates informational messages that highlight the progress of the application at coarse-grained level.
+    def info(text, additional_data = {})
+      begin
+        @logger.info(text)
+      rescue
+        #ignore
+      ensure
+        send_log(:info, text, additional_data)
+      end
+    end
+
+    # The WARN level designates potentially harmful situations.
+    def warn(text, additional_data = {})
+      begin
+        @logger.warn(text)
+      rescue
+        #ignore
+      ensure
+        send_log(:warn, text, additional_data)
+      end
+    end
+
+    # The ERROR level designates error events that might still allow the application to continue running.
+    def error(text, additional_data = {})
+      begin
+        @logger.error(text)
+      rescue
+        #ignore
+      ensure
+        send_log(:error, text, additional_data)
+      end
+    end
+
+    # The FATAL level designates very severe error events that will presumably lead the application to abort.
+    def fatal(text, additional_data = {})
+      begin
+        @logger.fatal(text)
+      rescue
+        #ignore
+      ensure
+        send_log(:fatal, text, additional_data)
+      end
+    end
+
+    # The TRACE Level designates finer-grained informational events than the DEBUG
+    def trace(text, additional_data = {})
+      begin
+        @logger.trace(text)
+      rescue
+        #ignore
+      ensure
+        send_log(:trace, text, additional_data)
+      end
+    end
+
+    # This method sends the log to Dynamicloud
+    # Dynamic provider will be created using the configuration in lonline.yml (csk and aci)
+    # If any error occurs a warning will be printed only if warning flag is true
+    # The additional_data param are additional data you need to send.
+    def send_log(level, text, additional_data = {})
+      unless Lonline::SETUP::SETTINGS[:config].nil?
+        # Verify logging level
+        allowed_level = Lonline::LEVELS[:off]
+        if Lonline::SETUP::SETTINGS[:config]['level'].nil?
+          Lonline.warn_it('Lonline is using default level :off')
+        else
+          allowed_level = Lonline::LEVELS[Lonline::SETUP::SETTINGS[:config]['level'].to_s.to_sym]
+          if allowed_level.nil?
+            Lonline.warn_it('Lonline is using default level :off')
+            allowed_level = Lonline::LEVELS[:off]
+          end
+        end
+
+        current_level = Lonline::LEVELS[level]
+
+        unless current_level >= allowed_level
+          return
+        end
+        # End of level verification
+
+        trace = {
+            :lonlinelevel => level.to_s,
+            :lonlinetext => text
+        }
+
+        trace.merge!(additional_data)
+
+        if Lonline::SETUP::SETTINGS[:config]['backtrace']
+          sub_array = caller[1..caller.length]
+          trace[:lonlinetrace] = sub_array.join("\n")
+        end
+
+        if Lonline::SETUP::SETTINGS[:config]['async']
+          Lonline.warn_it 'Async mode'
+
+          t = schedule(trace)
+
+          # For test environment the async mode is disabled.
+          if Lonline::SETUP::SETTINGS[:config]['env'].eql?('test')
+            Lonline.warn_it 'For test environment, the async process is disabled'
+
+            t.join
+          end
+        else
+          Lonline.warn_it 'Sync mode'
+          call_dynamicloud_service(trace)
+        end
+      end
+    end
+
+    def schedule(trace)
+      Thread.new {
+        call_dynamicloud_service(trace)
+      }
+    end
+
+    def call_dynamicloud_service(trace)
+      provider = Dynamicloud::API::DynamicProvider.new(
+          {
+              :csk => Lonline::SETUP::SETTINGS[:config]['csk'],
+              :aci => Lonline::SETUP::SETTINGS[:config]['aci']
+          })
+      begin
+        provider.save_record Lonline::SETUP::SETTINGS[:config]['model_identifier'], trace
+      rescue Exception => e
+        Lonline.warn_it(e.message)
+      end
+    end
+  end
+
+  # Global logger
+  LOGGER = Log.new
+
+  # This method returns the global logger.
+  def self.log
+    LOGGER
+  end
+
+  # Prints the warning
+  def self.warn_it(text)
+    if Lonline::SETUP::SETTINGS[:config]['warning']
+      puts "[Lonline WARN @ #{Time.new.utc.strftime('%d %B, %Y %T')}] - #{text}"
+    end
+  end
+
+  # This module provides methods to setup lonline
+  module SETUP
+    def self.logger=(logger)
+      LOGGER.logger = logger;
+    end
+
+    SETTINGS = {:config => {}}
+
+    # Load yml file with the settings to setup lonline
+    def self.load(file_name, env = ENV['LONLINE_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development')
+      begin
+        SETTINGS[:config] = YAML.load_file(file_name)[env]
+        SETTINGS[:config]['env'] = env
+      rescue Exception => e
+        Lonline.warn_it("It couldn't setup lonline.")
+        Lonline.warn_it(e.message)
+      end
+    end
+  end
+end

data/lib/lonline/version.rb

@@ -0,0 +1,3 @@
+module LONLINE
+  VERSION = '0.0.1'
+end

data/lib/lonline_report.rb

@@ -0,0 +1,161 @@
+#Copyright (c) 2016 Dynamicloud
+#
+#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.
+#
+# Lonline is a great tool to log your program into the cloud.
+# This module provides methods to get the stored logs from your account in Dynamicloud.
+#
+# Lonline::Report executes queries provided from Dynamicloud library and will
+# fetch until 100 records by default, if you want to increase this, set the number
+# of records in report_limit (lonline.yml)
+#
+# Additionally, Lonline::Record provides a method to count how many logs were printed
+# in a specific time.
+#
+# How to use:
+#
+# Lonline::Report.fetch(:error) do |report| # This call will fetch the error logs from now
+#   puts log[:text] # Log you have sent
+#   puts log[:trace] # Trace you have sent
+#   puts log[:when] # When this log was created
+#   puts report['additional'] #This could be an additional field you have sent
+# end
+#
+# Lonline::Report.fetch(:fatal, Time.new.utc) do |report| # This call will fetch the fatal logs from 2 days ago
+#   puts log[:text] # Log you have sent
+#   puts log[:trace] # Trace you have sent
+#   puts log[:when] # When this log was created
+# end
+#
+# Fetch how many logs were printed from Time.new.utc (Today)
+#
+# count = Lonline::Report.count(:fatal, Time.new.utc)
+# puts count
+
+require 'dynamic_api'
+require 'dynamic_criteria'
+
+module Lonline
+  # This module provides by default two methods fetch and count.  If you want to add your own reports, just
+  # add  the necessary methods to this module.
+  module Report
+    # This method counts the logs between a specific time according to 'from and to' params
+    #
+    # How to use:
+    #
+    # Fetch how many logs were printed from Time.new.utc (Today)
+    # count = Lonline::Report.count(:fatal, Time.new.utc)
+    # puts count
+    def self.count(level, from, to = Time.new.utc)
+      provider = get_provider
+
+      query = provider.create_query Lonline::SETUP::SETTINGS[:config]['model_identifier']
+      condition = Dynamicloud::API::Criteria::Conditions.and(Dynamicloud::API::Criteria::Conditions.equals('lonlinelevel', level.to_s),
+                                                             Dynamicloud::API::Criteria::Conditions.between('added_at', from.strftime('%Y-%m-%d %T'),
+                                                                                                            to.strftime('%Y-%m-%d %T')))
+
+      results = query.add(condition).get_results(['count(*) as count'])
+
+      results.records[0]['count'].to_i
+    end
+
+    # This method fetches the logs according to level param and will be those created between from and to params.
+    # The results are decrease ordered by creation.
+    #
+    # How to use:
+    #
+    # Lonline::Report.fetch(:fatal, Time.new.utc - 2.days) do |report| # This call will fetch the fatal logs from 2 days ago (Rails app)
+    #   puts log[:text] # Log you have sent
+    #   puts log[:trace] # Trace you have sent
+    #   puts log[:when] # When this log was created
+    #   puts report['additional'] #This could be an additional field you have sent
+    # end
+    #
+    # Lonline::Report.fetch(:fatal, Time.new.utc) do |report| # This call will fetch the fatal logs from today
+    #   puts log[:text] # Log you have sent
+    #   puts log[:trace] # Trace you have sent
+    #   puts log[:when] # When this log was created
+    # end
+    def self.fetch(level, from, to = Time.new.utc, &block)
+      provider = get_provider
+
+      query = provider.create_query Lonline::SETUP::SETTINGS[:config]['model_identifier']
+      condition = Dynamicloud::API::Criteria::Conditions.and(Dynamicloud::API::Criteria::Conditions.equals('lonlinelevel', level.to_s),
+                                                             Dynamicloud::API::Criteria::Conditions.between('added_at', from.strftime('%Y-%m-%d %T'),
+                                                                                                            to.strftime('%Y-%m-%d %T')))
+      results = query.order_by('id').desc.add(condition).get_results
+
+      handle_results(query, block, results, results.fast_returned_size)
+    end
+
+    private
+    # Returns the dynamicloud provider using the CSK and ACI provided from lonline.yml
+    def self.get_provider
+      Dynamicloud::API::DynamicProvider.new(
+          {
+              :csk => Lonline::SETUP::SETTINGS[:config]['csk'],
+              :aci => Lonline::SETUP::SETTINGS[:config]['aci']
+          })
+    end
+
+    # This method normalizes the records and will call the block passing the normalized record.
+    def self.handle_results(query, block, results, how_much_so_far)
+      results.records.each do |r|
+        block.call(normalize_record(r))
+      end
+
+      if how_much_so_far >= Lonline::SETUP::SETTINGS[:config]['report_limit'].to_i
+        return
+      end
+
+      # Dynamicloud provides the next method, this method automatically fetches the next set of logs.
+      results = query.next
+
+      if results.fast_returned_size > 0
+        handle_results(query, block, results, how_much_so_far + results.fast_returned_size)
+      end
+    end
+
+    # This method normalizes the record from Dynamicloud replacing the real field names to readable names
+    # For example: lonlinetext => text
+    #              created_at => when
+    def self.normalize_record(log)
+      normalized = {
+          :level => log['lonlinelevel'],
+          :text => log['lonlinetext'],
+          :trace => log['lonlinetrace'],
+          :when => log['added_at']
+      }
+
+      log.each do |k, v|
+        unless k.eql?('lonlinelevel') || k.eql?('lonlinetext') ||
+            k.eql?('lonlinetrace') || k.eql?('added_at') ||
+            k.eql?('id') || k.eql?('owner_id') || k.eql?('model_id') ||
+            k.eql?('changed_at')
+
+          normalized[k.to_sym] = v
+
+        end
+      end
+
+      normalized
+    end
+
+  end
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: lonline
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- lonline
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !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: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dynamicloud
+  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: json
+  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'
+description: "\n    You will be able to execute the following operations:\n    lonline.log.trace()
+  -\n    lonline.log.debug() -\n    lonline.log.info() -\n    lonline.log.warn() -\n
+  \   lonline.log.error() -\n    lonline.log.fatal() - Additionally, Lonline provides
+  methods to get report about your logs.\n  "
+email:
+- support@dynamicloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/lonline_generator.rb
+- lib/lonline.rb
+- lib/lonline/version.rb
+- lib/lonline_report.rb
+homepage: https://rubygems.org/gems/lonline
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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: This gem allows you to log your program into the cloud.
+test_files: []