RTALogger 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e8102f5e6bfb81e09e529d98b34039304aa7376d553e0df71e974a2eeaf6818d
+  data.tar.gz: 7a6558fa4df04b8bbaede48620644b7b85de448d96b7e93340d30f018a872461
+SHA512:
+  metadata.gz: 590a74703f4605c4a0df2e3a5a1997bf1c0209182b961ef74769f4c037f7fefb8770240d317e6017d3cf9ae30f1fc1cbd4e489c6e5c7f083b36f04b6d6f64bc6
+  data.tar.gz: 1dd9d109f63173420be1bbb6306d76eda10140c4474aa8b4de27f46ef7dbadceec58d5ba8816b03fa53de2cb6ee6b793ae3726ade97728aa3de55ec592e30255

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in RTALogger.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    RTALogger (0.1.0)
+      fluentd (~> 1.11, >= 1.11.4)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.1.7)
+    cool.io (1.7.0)
+    diff-lcs (1.4.4)
+    fluentd (1.11.4)
+      cool.io (>= 1.4.5, < 2.0.0)
+      http_parser.rb (>= 0.5.1, < 0.7.0)
+      msgpack (>= 1.3.1, < 2.0.0)
+      serverengine (>= 2.0.4, < 3.0.0)
+      sigdump (~> 0.2.2)
+      strptime (>= 0.2.2, < 1.0.0)
+      tzinfo (>= 1.0, < 3.0)
+      tzinfo-data (~> 1.0)
+      yajl-ruby (~> 1.0)
+    http_parser.rb (0.6.0)
+    msgpack (1.3.3)
+    rake (12.3.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    serverengine (2.2.2)
+      sigdump (~> 0.2.2)
+    sigdump (0.2.4)
+    strptime (0.2.5)
+    tzinfo (2.0.2)
+      concurrent-ruby (~> 1.0)
+    tzinfo-data (1.2020.4)
+      tzinfo (>= 1.0.0)
+    yajl-ruby (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  RTALogger!
+  rake (~> 12.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 =
+
+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,40 @@
+# RTALogger
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/RTALogger`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'RTALogger'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install RTALogger
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. 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/[USERNAME]/RTALogger.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/RTALogger.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/RTALogger/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "RTALogger"
+  spec.version       = RTALogger::VERSION
+  spec.authors       = ["Babak Bahreini, RTA Backend Team"]
+  spec.email         = ["b.bahreini@roundtableapps.com"]
+
+
+  spec.summary       = %q{An easy to use, easy to extend log manager to prepare standard log API for developers }
+  spec.description   = %q{RTA Log Manager has been designed and implemented to provide standard logging API for developers.This prevents chaos in log data format. Also provide multiple extendable log repositories including wrapping existing loggers, like 'Fluentd' or implement completely new custom logger. All main features of log manager are configeable through a json config file.}
+  spec.homepage      = "https://github.com/BBahrainy/RTALogger.git"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = "https://www.rubygems.org"
+
+  spec.metadata["homepage_uri"] = "https://github.com/BBahrainy/RTALogger.git"
+  spec.metadata["source_code_uri"] = "https://github.com/BBahrainy/RTALogger.git"
+  spec.metadata["changelog_uri"] = "https://github.com/BBahrainy/RTALogger.git"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "fluentd", "~> 1.11", ">= 1.11.4"
+end

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "RTALogger"
+
+# 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(__FILE__)

data/bin/setup

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

data/lib/RTALogger.rb

@@ -0,0 +1,6 @@
+require "RTALogger/version"
+
+module RTALogger
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/RTALogger/version.rb

@@ -0,0 +1,3 @@
+module RTALogger
+  VERSION = "0.1.0"
+end

data/lib/factory/origin/log_factory_file_logger.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+require 'logger'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.new_file_logger(file_path = 'log.txt', period = 'daily', shift_size = 1048576)
+      @ruby_logger = Logger.new(file_path, period, shift_size)
+      @ruby_logger.level = Logger::Severity::DEBUG
+      @ruby_logger.formatter = proc do |severity, datetime, progname, msg|
+        "#{msg}\n"
+      end
+      @ruby_logger
+    end
+  end
+end

data/lib/factory/origin/log_factory_log_formatter.rb

@@ -0,0 +1,11 @@
+require_relative '../../log_formatter_text'
+require_relative '../../log_formatter_json'
+
+module RTALogger
+  module LogFactory
+    def self.log_formatter_default
+      # RTALogger::LogFormatterJSON.new
+      RTALogger::LogFormatterText.new
+    end
+  end
+end

data/lib/factory/origin/log_factory_manager.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative '../../log_manager'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.log_manager_instance
+      RTALogger::LogManager.instance
+    end
+
+
+  end
+end

data/lib/factory/origin/log_factory_propagator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../log_propagator'
+#require_relative './log_repository_console'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.new_log_propagator
+      LogPropagator.new
+    end
+  end
+end

data/lib/factory/origin/log_factory_record.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../../log_record'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.new_log_record(log_topic, context_id, severity, *message)
+      LogRecord.new(log_topic, context_id, severity, message)
+    end
+  end
+end

data/lib/factory/origin/log_factory_repository.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../log_repository_console'
+require_relative '../../log_repository_file'
+require_relative '../../log_repository_udp'
+#require_relative '../../log_repository_db'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.new_log_repository_console
+      LogRepositoryConsole.new
+    end
+
+    def self.new_log_repository_file(file_path = 'log.txt', period = 'daily', shift_size = 1048576)
+      LogRepositoryFile.new(file_path, period, shift_size)
+    end
+
+    def self.load_log_repository_file(config_json)
+      file_path = config_json['File_Path'].to_s
+      period = config_json['Roll_Period'].to_s
+      shift_size = config_json['Roll_Size'].nil? ? 1048576 : config_json['Roll_Size'].to_i
+      ::RTALogger::LogFactory.new_log_repository_file(file_path, period, shift_size)
+    end
+
+    def self.new_log_repository_udp(host = '127.0.0.1', port = 4913)
+      LogRepositoryUDP.new(host, port)
+    end
+
+    def self.load_log_repository_udp(config_json)
+      host = config_json['Host'].to_s
+      port = config_json['Port'].nil? ? 4913 : config_json['Port'].to_i
+      ::RTALogger::LogFactory.new_log_repository_udp(host, port)
+    end
+
+    def self.create_repository(type, config_json)
+      result = nil
+      result = new_log_repository_console if type.to_s.upcase.eql?('Console'.upcase)
+      result = load_log_repository_file(config_json) if type.to_s.upcase.eql?('File'.upcase)
+      result = load_log_repository_udp(config_json) if type.to_s.upcase.eql?('UDP'.upcase)
+      result
+    end
+  end
+end

data/lib/factory/origin/log_factory_topic.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../../log_topic'
+
+module RTALogger
+  # this module generates object instance
+  module LogFactory
+    def self.new_log_topic(log_manager, topic_title, level = WARN)
+      LogTopic.new(log_manager, topic_title, level)
+    end
+  end
+end

data/lib/log_formatter.rb

@@ -0,0 +1,8 @@
+module RTALogger
+  class LogFormatter
+    def format(log_record)
+      log_record.to_s
+    end
+  end
+end
+

data/lib/log_formatter_json.rb

@@ -0,0 +1,21 @@
+require 'jbuilder'
+require_relative 'log_formatter'
+
+module RTALogger
+  class LogFormatterJSON
+    def format(log_record)
+      return '' unless log_record
+
+      jb = Jbuilder.new do |json|
+        json.occurred_at log_record.occurred_at.strftime("%F %H:%M:%S:%3N")
+        json.app_name log_record.app_name
+        json.topic_title log_record.topic_title
+        json.context_id log_record.context_id
+        json.severity log_record.severity
+        json.message log_record.message.flatten.join(' ')
+      end
+
+      jb.target!
+    end
+  end
+end

data/lib/log_formatter_text.rb

@@ -0,0 +1,18 @@
+require_relative 'log_formatter'
+
+module RTALogger
+  class LogFormatterText < LogFormatter
+    def format(log_record)
+      return '' unless log_record
+
+      result = log_record.occurred_at.strftime("%F %H:%M:%S:%3N")
+      result << '|' << log_record.app_name
+      result << '|' << log_record.topic_title
+      result << '|' << log_record.context_id
+      result << '|' << log_record.severity
+      result << '|' << log_record.message.join(' ').gsub('|' , '$<$')
+
+      result
+    end
+  end
+end

data/lib/log_manager.rb

@@ -0,0 +1,141 @@
+require 'date'
+require 'thread'
+require 'singleton'
+require_relative 'factory/origin/log_factory_propagator'
+require_relative 'factory/origin/log_factory_repository'
+require_relative 'factory/origin/log_factory_topic'
+require_relative './log_severity'
+
+# the module will contain all logger requirements
+module RTALogger
+  # the class is the main class
+  class LogManager
+    include Singleton
+    include LogSeverity
+    include RTALogger::LogFactory
+
+    def initialize
+      @enable = true
+      @app_name = ENV.fetch('RTALogger_App_Name', 'unknownApp')
+      @default_log_level = ENV.fetch('RTALogger_Log_Severity', ::RTALogger::LogSeverity::WARN)
+      @topic_semaphore = Mutex.new
+      @log_semaphore = Mutex.new
+      @buffer_size = ENV.fetch('RTALogger_Buffer_Size', 100)
+      @flush_size = @buffer_size * 20 / 100
+      @flush_wait_time = ENV.fetch('RTALogger_Flush_Wait_Seconds', 15)
+      @topics = {}
+      @log_records = []
+      @propagator = LogFactory.new_log_propagator
+      @last_flush_time = DateTime.now
+      @exit_flush_scheduler = false
+      initialize_flush_scheduler
+      ObjectSpace.define_finalizer(self, proc {
+        @exit_flush_scheduler = true
+        flush_all
+      })
+      @flush_scheduler.run
+    end
+
+    def config(config_file_name)
+      config_json = load_config_from_file(config_file_name)
+      raise 'json config not available' unless config_json
+      @enable = config_json['Enable'].nil? ? true : config_json['Enable']
+      @app_name = config_json['App_Name'] if config_json['App_Name'].present?
+      @default_log_level = config_json['Log_Severity'] if config_json['Log_Severity'].present?
+      @buffer_siz = config_json['Buffer_Size'] if config_json['Buffer_Size'].present?
+      @flush_wait_time = config_json['Flush_Wait_Seconds'] if config_json['Flush_Wait_Seconds'].present?
+      @propagator.drop_all_repositories
+      config_json['Repos']&.each { |item| @propagator.load_log_repository(item) }
+    rescue StandardError => e
+      puts e.message
+      @propagator.drop_all_repositories
+      @propagator.add_log_repository(LogFactory.new_log_repository_console)
+    end
+
+    attr_accessor :enable
+    attr_accessor :app_name
+    attr_reader :propagator
+
+    def add_topic(topic_title, log_level = @default_log_level)
+      @topic_semaphore.synchronize {
+        @topics[topic_title.to_sym] ||= LogFactory.new_log_topic(self, topic_title, log_level)
+      }
+
+      @topics[topic_title.to_sym].enable = @enable
+      @topics[topic_title.to_sym]
+    end
+
+    def add_log(log_record)
+      return unless @enable
+      @log_semaphore.synchronize { @log_records.push(log_record) }
+      check_for_flush
+    end
+
+    def update_topic_log_level(topic, log_level = WARN)
+      @topic_semaphore.synchronize { @topics[topic].log_level = log_level if @topics[topic] }
+    end
+
+    def update_all_topics_log_level(log_level = WARN)
+      @topic_semaphore.synchronize { @topics.keys.each { |topic| @topics[topic].log_level = log_level } }
+    end
+
+    private
+
+    def load_config_from_file(config_file_name)
+      config_file = File.open config_file_name
+      config_json = JSON.load config_file
+      config_json = config_json['RTALogger']
+      raise 'RTALogger configuration not found!' unless config_json
+      raise 'Log_Managers section does not exists json configuration' unless config_json['Log_Managers']
+      raise 'No config manager defined in json configuration' unless config_json['Log_Managers'].count.positive?
+      manager_name = config_json['Default_Manager']
+      unless manager_name.to_s.strip.empty?
+        config_json = config_json['Log_Managers'].find { |item| item['Manager_Name'] == manager_name }
+      end
+      config_json ||= config_json['Log_Managers'][0]
+      raise 'Unable to extract RTA Log Manager configuration!' unless config_json
+      config_json
+    end
+
+    def initialize_flush_scheduler
+      @flush_scheduler = Thread.new do
+        loop do
+          elapsed_seconds = ((DateTime.now - @last_flush_time) * 24 * 60 * 60).to_i
+          flush if elapsed_seconds > @flush_wait_time
+          sleep(1)
+          break if @exit_flush_scheduler
+        end
+      end
+    end
+
+    def check_for_flush
+      flush if count > @buffer_size
+    end
+
+    def count
+      @log_semaphore.synchronize { @log_records.count }
+    end
+
+    def flush
+      @last_flush_time = DateTime.now
+      @log_semaphore.synchronize do
+        @log_records[0...@flush_size].each { |log| propagate(log) }
+      end
+      @log_semaphore.synchronize { @log_records.shift(@flush_size) }
+      propagate_thread = Thread.new { @propagator.propagate }
+      propagate_thread.join
+    end
+
+    def flush_all
+      @log_semaphore.synchronize do
+        @log_records[0...@log_records.count].each { |log|  propagate(log) }
+        @log_records.clear
+      end
+      @propagator.propagate
+    end
+
+    def propagate(log_record)
+      @propagator.add_log(log_record)
+    end
+  end
+end

data/lib/log_propagator.rb

@@ -0,0 +1,45 @@
+require 'thread'
+require_relative './log_repository'
+
+module RTALogger
+  # propagate log records to multiple log repositories
+  class LogPropagator
+    def initialize
+      @semaphore = Mutex.new
+      @log_records = []
+      @log_repositories = []
+    end
+
+    def add_log(log_record)
+      @semaphore.synchronize { @log_records.push(log_record.dup) }
+    end
+
+    def add_log_repository(log_repository)
+      return unless log_repository.is_a? RTALogger::LogRepository
+      @log_repositories.push(log_repository) unless @log_repositories.include?(log_repository)
+    end
+
+    def load_log_repository(config_json)
+      type = config_json['Type']
+      return if type.to_s.strip.empty?
+      enable = config_json['Enable'].nil? ? true : config_json['Enable']
+      return unless enable
+
+      log_repository = ::RTALogger::LogFactory.create_repository(type, config_json)
+      add_log_repository(log_repository)
+    end
+
+    def drop_all_repositories
+      @semaphore.synchronize { @log_repositories.clear }
+    end
+
+    def propagate
+      @semaphore.synchronize do
+        @log_repositories.each do |log_repository|
+          log_repository.add_log_records(@log_records)
+        end
+        @log_records.clear
+      end
+    end
+  end
+end

data/lib/log_record.rb

@@ -0,0 +1,28 @@
+require 'date'
+
+module RTALogger
+  # log data structure
+  class LogRecord
+    def initialize(log_topic, context_id, severity, *message)
+      @log_topic = log_topic
+      @context_id = context_id
+      @severity = severity
+      @message = message
+      @occurred_at = DateTime.now
+    end
+
+    attr_reader :context_id
+    attr_reader :severity
+    attr_reader :message
+    attr_reader :occurred_at
+
+    def app_name
+      @log_topic.log_manager.app_name
+    end
+
+    def topic_title
+      @log_topic.topic_title
+    end
+  end
+end
+

data/lib/log_repository.rb

@@ -0,0 +1,31 @@
+require 'thread'
+
+module RTALogger
+  # base log repository class
+  class LogRepository
+    def initialize
+      @semaphore = Mutex.new
+      @log_records = []
+      @enable = true
+    end
+
+    def add_log_records(items)
+      return 0 unless @enable
+      @semaphore.synchronize do
+        items.each { |item| @log_records.push(item.dup) }
+      end
+      flush_and_clear
+    end
+
+    attr_accessor :enable
+
+    protected
+
+    def flush_and_clear
+      @semaphore.synchronize { @log_records.clear }
+    end
+
+    attr_reader :log_records
+    attr_reader :semaphore
+  end
+end

data/lib/log_repository_console.rb

@@ -0,0 +1,23 @@
+require_relative 'log_repository'
+require_relative 'factory/origin/log_factory_log_formatter'
+
+module RTALogger
+  # show log items on console out put
+  class LogRepositoryConsole < LogRepository
+    def initialize
+      super
+
+      @formatter = RTALogger::LogFactory::log_formatter_default
+    end
+
+    protected
+
+    def flush_and_clear
+      semaphore.synchronize do
+        @log_records.each { |log_record| puts @formatter.format(log_record) }
+      end
+      super
+    end
+
+  end
+end

data/lib/log_repository_file.rb

@@ -0,0 +1,25 @@
+require 'logger'
+require_relative 'log_repository'
+require_relative 'factory/origin/log_factory_file_logger'
+require_relative 'factory/origin/log_factory_log_formatter'
+
+module RTALogger
+  # show log items on console out put
+  class LogRepositoryFile < LogRepository
+    def initialize(file_path = 'log.txt', period = 'daily', shift_size = 1048576)
+      super()
+      @file_logger = RTALogger::LogFactory.new_file_logger(file_path, period, shift_size)
+      @formatter = RTALogger::LogFactory::log_formatter_default
+    end
+
+    protected
+
+    def flush_and_clear
+      semaphore.synchronize do
+        @log_records.each { |log_record| @file_logger.debug(@formatter.format(log_record)) }
+      end
+      super
+    end
+
+  end
+end

data/lib/log_repository_udp.rb

@@ -0,0 +1,25 @@
+require 'socket'
+
+module RTALogger
+  # show log items on console out put
+  class LogRepositoryUDP < LogRepository
+    def initialize(host = '127.0.0.1', port = 4913)
+      super()
+      @host = host
+      @port = port
+    end
+
+    protected
+
+    def flush_and_clear
+      semaphore.synchronize do
+        u1 = UDPSocket.new
+        u1.bind(@host, @port)
+        @log_records.each { |log_record| u1.send log_record.to_s, 0, @host, @port}
+        u1.close
+      end
+      super
+    end
+
+  end
+end

data/lib/log_severity.rb

@@ -0,0 +1,17 @@
+module RTALogger
+  # Logging severity.
+  module LogSeverity
+    # Low-level information, mostly for developers.
+    DEBUG = 0
+    # Generic (useful) information about system operation.
+    INFO = 1
+    # A warning.
+    WARN = 2
+    # A handleable error condition.
+    ERROR = 3
+    # An unhandleable error that results in a program crash.
+    FATAL = 4
+    # An unknown message that should always be logged.
+    UNKNOWN = 5
+  end
+end

data/lib/log_test.rb

@@ -0,0 +1,41 @@
+#require 'logger'
+#require 'date'
+require_relative 'factory/origin/log_factory_manager'
+require_relative 'factory/origin/log_factory_repository'
+require 'socket'
+
+controller_name = 'test_controller'
+userID = 5
+
+log_manager = RTALogger::LogFactory.log_manager_instance
+log_manager.app_name = 'myTestApp'
+log_manager.config('../../../config/rta_logger_config.json')
+#log_manager.propagator.add_log_repository(RTALogger::LogFactory.new_log_repository_console)
+#log_manager.propagator.add_log_repository(RTALogger::LogFactory.new_log_repository_file('../../../log/log.txt'))
+#log_manager.propagator.add_log_repository(RTALogger::LogFactory.new_log_repository_udp('127.0.0.1', 4913))
+# log_manager.propagator.add_log_repository(RTALogger::LogFactory.new_log_repository_db)
+
+topic = log_manager.add_topic(controller_name)
+
+topic.info(userID, 'Controller Name=', controller_name, 'Called by client 1')
+
+#logger.level = RTALogger::LogSeverity::INFO
+#manager.update_topic_level(controller_name, RTALogger::LogSeverity::INFO)
+
+log_manager.update_all_topics_log_level(RTALogger::LogSeverity::INFO)
+
+topic.info(userID, 'Controller Name|', controller_name, 'Called by client |2|')
+topic.error(userID, 'Controller Name=', controller_name, 'Called by client 3')
+
+#sleep(10)
+
+topic.info(userID, 'Controller Name=', controller_name, 'Called by client |4|')
+topic.fatal(userID, 'Controller Name=', controller_name, 'Called by client 5')
+topic.info(userID, 'Controller Name=', controller_name, 'Called by client 6')
+
+#ruby_logger = Logger.new(STDOUT)
+#ruby_logger.formatter = proc do |severity, datetime, progname, msg|
+#  "NICE: #{msg}\n"
+#end
+#ruby_logger.info('logged by ruby default logger')
+

data/lib/log_test_db.rb

@@ -0,0 +1,59 @@
+#require 'active_record'
+#require 'pg'
+# require 'active_record'  # uncomment for not Rails environment
+
+#ActiveRecord::Base.establish_connection(:adapter => "postgresql",
+#                                        :username => "postgre",
+#                                        :database => "rails_test_development")
+
+require 'log_record'
+
+module RTALogger
+  class LogFormatter
+    def initialize(log_record,
+                   delimiter = '|',
+                   time_format = '%Y-%m-%d %H:%M:%S.%3N')
+      @log_record = log_record
+      @delimiter = delimiter
+      @time_format = time_format
+      @format_chance = format_chance
+    end
+
+    attr_accessor :log_record
+    attr_accessor :delimiter
+    attr_accessor :time_format
+
+    def self.default_formatter(log_record)
+      LogFormatter.new(log_record)
+    end
+
+    def to_s
+      result = "#{occurred_at}#{@delimiter}#{@log_record.app_name}#{@delimiter}"
+      result << "#{@log_record.topic_title}#{@delimiter}#{@log_record.context_id}"
+      result << "#{@delimiter}#{@log_record.severity}#{@delimiter}#{log_message}"
+
+      if @format_chance
+        result unless @format_chance.call(occurred_at,
+                                          @log_record.app_name,
+                                          @log_record.topic_title,
+                                          @log_record.context_id,
+                                          @log_record.severity,
+                                          log_message)
+      end
+      else
+        result
+      end
+    end
+
+    protected
+
+    def log_message
+      @log_record.message.join.gsub(delimiter, '&dlm&')
+    end
+
+    def occurred_at
+      @log_record.occurred_at.strftime(time_format)
+    end
+  end
+end
+

data/lib/log_topic.rb

@@ -0,0 +1,57 @@
+# topic
+
+require_relative './log_severity'
+require_relative 'factory/origin/log_factory_record'
+
+module RTALogger
+  # the main class to logging data
+  class LogTopic
+    include LogSeverity
+    include RTALogger::LogFactory
+
+    def initialize(log_manager, topic_title, log_level = WARN)
+      #  Logger logger = Logger.new(Logger::DEBUG)
+      @enable = true
+      @log_manager = log_manager
+      @topic_title = topic_title.to_s.dup
+      @log_level = log_level
+    end
+
+    attr_accessor :enable
+    attr_reader :log_manager
+    attr_reader :topic_title
+    attr_accessor :log_level
+
+    def debug(context_id, *message)
+      add(context_id, DEBUG, message) if @log_level.to_i <= DEBUG.to_i
+    end
+
+    def info(context_id, *message)
+      add(context_id, INFO, message) if @log_level.to_i <= INFO.to_i
+    end
+
+    def warning(context_id, *message)
+      add(context_id, WARN, message) if @log_level.to_i <= WARN.to_i
+    end
+
+    def error(context_id, *message)
+      add(context_id, ERROR, message) if @log_level.to_i <= ERROR.to_i
+    end
+
+    def fatal(context_id, *message)
+      add(context_id, FATAL, message) if @log_level.to_i <= FATAL.to_i
+    end
+
+    def unknown(context_id, *message)
+      add(context_id, UNKNOWN, message) if @log_level.to_i <= UNKNOWN.to_i
+    end
+
+    private
+
+    def add(context_id, severity, *message)
+      return unless @enable
+      log_record = LogFactory.new_log_record(self, context_id, severity, message)
+      @log_manager.add_log(log_record)
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: RTALogger
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Babak Bahreini, RTA Backend Team
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fluentd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.4
+description: RTA Log Manager has been designed and implemented to provide standard
+  logging API for developers.This prevents chaos in log data format. Also provide
+  multiple extendable log repositories including wrapping existing loggers, like 'Fluentd'
+  or implement completely new custom logger. All main features of log manager are
+  configeable through a json config file.
+email:
+- b.bahreini@roundtableapps.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- RTALogger.gemspec
+- Rakefile
+- bin/console
+- bin/setup
+- lib/RTALogger.rb
+- lib/RTALogger/version.rb
+- lib/factory/origin/log_factory_file_logger.rb
+- lib/factory/origin/log_factory_log_formatter.rb
+- lib/factory/origin/log_factory_manager.rb
+- lib/factory/origin/log_factory_propagator.rb
+- lib/factory/origin/log_factory_record.rb
+- lib/factory/origin/log_factory_repository.rb
+- lib/factory/origin/log_factory_topic.rb
+- lib/log_formatter.rb
+- lib/log_formatter_json.rb
+- lib/log_formatter_text.rb
+- lib/log_manager.rb
+- lib/log_propagator.rb
+- lib/log_record.rb
+- lib/log_repository.rb
+- lib/log_repository_console.rb
+- lib/log_repository_file.rb
+- lib/log_repository_udp.rb
+- lib/log_severity.rb
+- lib/log_test.rb
+- lib/log_test_db.rb
+- lib/log_topic.rb
+homepage: https://github.com/BBahrainy/RTALogger.git
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://www.rubygems.org
+  homepage_uri: https://github.com/BBahrainy/RTALogger.git
+  source_code_uri: https://github.com/BBahrainy/RTALogger.git
+  changelog_uri: https://github.com/BBahrainy/RTALogger.git
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: An easy to use, easy to extend log manager to prepare standard log API for
+  developers
+test_files: []