remote_logger 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 arvicco
+
+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.rdoc

@@ -0,0 +1,61 @@
+remote_logger
+    by: arvicco
+    url: http://github.com/arvicco/remote_logger
+
+== DESCRIPTION:
+
+Log server/client with sensible defaults that can be used for remote/centralized logging.
+
+== FEATURES:
+
+Log4r is a customizable logger with advanced functionality. Unfortunately, it only supports (rarely used) ROMP protocol
+for remote logging support. This project aims to improve remote logging by creatting a wrapper around Log4r that:
+* Exposes Log4r functionality remotely through multiple protocols
+* Writes to (log server) stdout AND log file 'remote.log' by default
+* Allows client to use Drb uri or Ring server to find the logger service
+
+== PROBLEMS/TODO:
+
+* TODO: add AMQP rpc support
+
+  Work in progress, please do not use it just yet...
+
+== SYNOPSIS:
+
+server:
+---
+  include RemoteLogger
+  start_drb_logger [options] # or,
+  start_ringy_logger [options]
+---
+
+client:
+---
+  include RemoteLogger
+  log = find_drb_logger [options] # or,
+  log = find_ringy_logger [options]
+  log.info 'This is my log message'
+---
+
+== REQUIREMENTS:
+
+* FIXME (list of requirements)
+
+== INSTALL:
+
+  sudo gem install remote_logger
+
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 arvicco. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "remote_logger"
+    gem.summary = %Q{Remote logger based on Log4r}
+    gem.description = %Q{Remote logger based on Log4r}
+    gem.email = "arvitallian@gmail.com"
+    gem.homepage = "http://github.com/arvicco/remote_logger"
+    gem.authors = ["arvicco"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "cucumber", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "remote_logger #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/features/remote_logger.feature

@@ -0,0 +1,9 @@
+Feature: something something
+  In order to something something
+  A user something something
+  something something something
+
+  Scenario: something something
+    Given inspiration
+    When I create a sweet new gem
+    Then everyone should see how awesome I am

data/features/support/env.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'remote_logger'
+
+require 'spec/expectations'

data/lib/remote_logger/remote_logger.rb

@@ -0,0 +1,104 @@
+#encoding: UTF-8
+# TODO: Set up ACL, SSL and other security stuff
+module RemoteLogger
+  include Log4r
+
+  DRB_URI = 'druby://127.0.0.1:61626'
+  LOGGER_NAME = 'RemoteLogger' # Default service/logger name - used by Ring or retrieved via Log4R::Logger[LOGGER_NAME]
+  FILE_NAME = 'remote.log' # File name of log file
+  FILE_ENCODING = 'CP1251:UTF-8' # Encoding pair of log file ('File external:Ruby internal')
+  STDOUT_ENCODING = 'CP866:UTF-8' # Encoding pair of stdout ('Stdout external:Ruby internal')
+  PATTERN = '%1.1l %d - %m' # Log entry pattern
+  DATE_PATTERN = '%Y-%m-%d %H:%M:%S.%3N'
+
+  # Creates a new Log4r logger. The following options are available:
+  #
+  # <tt>:name</tt>:: Service/logger name - default 'RemoteLogger'
+  # <tt>:outputters</tt>:: Replace outputters (should be Log4r::Outputter subclasses) - default [log file, stdout]
+  # <tt>:file_name</tt>:: Log file name - default 'remote.log'
+  # <tt>:file_encoding</tt>:: Log file encoding - default FILE_ENCODING (Windows Cyrillic)
+  # <tt>:stdout_encoding</tt>:: Stdout encoding - default STDOUT_ENCODING (DOS/IBM Cyrillic)
+  # <tt>:replace</tt>:: Replacement for undefined conversion chars - default '?'
+  # <tt>:pattern</tt>:: Log message pattern - default PATTERN
+  # <tt>:date_pattern</tt>:: Timestamp pattern - default DATE_PATTERN
+  # <tt>:trunc</tt>:: Truncate (rewrite) log file upon creation  - default false (append to file)
+  # <tt>:verbose</tt>:: Log all internal messages of RemoteLogger - default false (do not log logger-specific messages)
+  #
+  def self.create_logger options = {}
+    # define outputters: http://log4r.sourceforge.net/rdoc/files/log4r/outputter/outputter_rb.html
+    if options[:outputters]
+      outputters = options[:outputters]
+    else
+      # specify log message format: http://log4r.sourceforge.net/rdoc/files/log4r/formatter/patternformatter_rb.html
+      format = PatternFormatter.new :pattern => options[:pattern]||PATTERN,
+                                    :date_pattern => options[:date_pattern]||DATE_PATTERN
+
+      # Set up IO streams with correct transcoding and conversion options: log file and (Windows) console
+      conversion = {:undef=>:replace, :replace=>options[:replace]||'?'}
+      file = File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
+              (options[:file_encoding]||FILE_ENCODING), conversion )
+      $stdout.set_encoding(options[:stdout_encoding]||STDOUT_ENCODING, conversion)
+
+      outputters = [StdoutOutputter.new('console', :formatter => format),
+                    IOOutputter.new('file', file, :formatter => format) ]
+#   file_o = FileOutputter.new 'file', :filename => 'remote.log', :trunc => false, :formatter => format # wrong encoding
+#   err_o = StderrOutputter.new 'error', :formatter => format # just in case
+    end
+
+    # create new logger named LOG_NAME
+    Logger.new(options[:name]||LOGGER_NAME).tap do |logger|
+      logger.outputters = outputters
+      logger.info "#{name}: Logger created" if options[:verbose]
+    end
+  end
+
+  def self.start_ringy_logger(name = LOGGER_NAME, options = {})
+    # Adding some security (disable remote eval)
+    $SAFE = 1
+
+    # Creating logger instance
+    logger = create_logger options
+
+    DRb.start_service
+
+    # Raising new RingyDingy service
+    logger.info "#{name}: Initializing service..." if options[:verbose]
+    RingyDingy.new(logger, name.to_sym).run
+    logger.info "#{name}: Service started" if options[:verbose]
+
+    DRb.thread.join
+    logger.info "#{name}: Service finished" if options[:verbose]
+  end
+
+  def self.find_ringy_logger(name = LOGGER_NAME, options = {})
+    DRb.start_service
+    # Connecting to Logger
+    ring_server = Rinda::RingFinger.primary
+    service = ring_server.read [:name, name.to_sym, nil, nil]
+    service[2]
+  end
+
+  def self.start_drb_logger(name = LOGGER_NAME, options = {})
+    # Adding some security (disable remote eval)
+    $SAFE = 1
+
+    # Creating logger instance
+    logger = create_logger options
+
+    # Raising new RingyDingy service
+    logger.info "#{name}: Initializing service..." if options[:verbose]
+    DRb.start_service(options[:uri]||DRB_URI, logger)
+    logger.info "#{name}: Service started" if options[:verbose]
+
+    DRb.thread.join
+    logger.info "#{name}: Service finished" if options[:verbose]
+  end
+
+  def self.find_drb_logger(name = LOGGER_NAME, options = {})
+    DRb.start_service
+    # Connecting to Logger
+    log = DRbObject.new_with_uri(options[:uri]||DRB_URI)
+  end
+
+
+end

data/lib/remote_logger.rb

@@ -0,0 +1,24 @@
+require 'log4r'
+require 'rinda/ring'
+require 'ringy_dingy'
+#require 'ringy_dingy/ring_server'
+
+module RemoteLogger
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module RemoteLogger
+
+RemoteLogger.require_all_libs_relative_to(__FILE__)
+

data/spec/remote_logger/remote_logger_spec.rb

@@ -0,0 +1,132 @@
+#encoding: UTF-8
+require_relative '../spec_helper'
+
+module RemoteLoggerTest
+  describe RemoteLogger do
+    before(:each) do
+      File.stub!(:new) {|name, mode, opts| @logfile_mock = StringIO.new('', mode) }
+    end
+
+    spec {use { include RemoteLogger}}
+
+    shared_examples_for 'Log4r proxy' do
+      context ' by default' do
+        it 'creates Log4r logger with default name "RemoteLogger"' do
+          logger = RemoteLogger.create_logger
+          logger.should be_an_instance_of Log4r::Logger
+          logger.should == Log4r::Logger['RemoteLogger']
+          logger.should == RemoteLogger::Logger['RemoteLogger']
+        end
+
+        it 'outputs log messages to IOstream(file) and stdout simultaneously' do
+          outputters = RemoteLogger.create_logger.outputters
+          outputters.should have(2).outputters
+          outputters.first.should be_an_instance_of Log4r::StdoutOutputter
+          outputters.last.should be_an_instance_of Log4r::IOOutputter
+        end
+
+        it 'appends to logfile "remote.log" with Windows-1251(Cyrillic) encoding' do
+          File.should_receive(:new) do |filename, mode, options|
+            filename.should == "remote.log"
+            mode.should =~ /^a:/
+            mode.should =~ /(CP|cp)1251:/
+          end
+          logger = RemoteLogger.create_logger
+        end
+
+        it 'writes to stdout with IBM-866(DOS-Cyrillic) encoding' do
+          $stdout.should_receive(:set_encoding).with(/(CP|cp)866:/, hash_including(:undef))
+          logger = RemoteLogger.create_logger
+        end
+
+        it 'logs string messages using default pattern' do
+          logger = RemoteLogger.create_logger
+          logger_should_log 'I %Y-%m-%d %H:%M:\d{2}.\d{3} - My message\n'
+          logger.info 'My message'
+        end
+
+        it 'logs logger creation announcement'
+
+        it 'replaces illegal chars in output codepages with ?' do
+          pending 'Impossible to test without real files'
+          logger_should_log 'I %Y-%m-%d %H:%M:\d{2}.\d{3} - My ? message\n'
+          logger = RemoteLogger.create_logger
+          logger.info 'My 昔 message'
+        end
+      end
+
+      context 'with options' do
+        it 'accepts logger name with :name option' do
+          logger = RemoteLogger.create_logger :name=>'MyLogger'
+          logger.should == Log4r::Logger['MyLogger']
+          logger.should == RemoteLogger::Logger['MyLogger']
+        end
+
+        it 'accepts logfile name with :file_name option' do
+          File.should_receive(:new).with('my_name.log', anything, anything)
+          logger = RemoteLogger.create_logger :file_name=>'my_name.log'
+        end
+
+        it 'accepts custom log pattern with :pattern option' do
+          logger = RemoteLogger.create_logger :pattern=>'%d %l %7.7m'
+          logger_should_log '%Y-%m-%d %H:%M:\d{2}.\d{3} INFO My mess\n'
+          logger.info 'My message'
+        end
+
+        it 'accepts custom date pattern with :date_pattern option' do
+          logger = RemoteLogger.create_logger :date_pattern=>'%m/%d/%y'
+          logger_should_log 'I %m/%d/%y - My message\n'
+          logger.info 'My message'
+        end
+
+        it 'accepts custom file encoding with :file_encoding option' do
+          File.should_receive(:new).with(anything, /^a:CP866/, anything)
+          logger = RemoteLogger.create_logger :file_encoding=>'CP866'
+        end
+
+        it 'accepts custom stdout encoding with :stdout_encoding option' do
+          $stdout.should_receive(:set_encoding).with(/CP1251/, hash_including(:undef))
+          logger = RemoteLogger.create_logger :stdout_encoding=>'CP1251'
+        end
+
+        it 'accepts custom outputters with :outputters option, replacing default outputters' do
+          out_string = StringIO.new
+          $stdout.should_not_receive(:set_encoding)
+          File.should_not_receive(:new)
+          logger = RemoteLogger.create_logger :outputters=>Log4r::IOOutputter.new('errors', out_string)
+          $stdout.should_not_receive(:print)
+          out_string.should_receive(:print).with " INFO RemoteLogger: My message\n"
+          logger.info 'My message'
+        end
+
+        it 'rewrites logfile with :trunc option' do
+          File.should_receive(:new).with(anything, /^w:/, anything)
+#         File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
+#                   (options[:file_encoding]||FILE_ENCODING), :undef => options[:undef]||:replace)
+          logger = RemoteLogger.create_logger :trunc=>true
+        end
+
+        it 'specifies conversion replacement char with :replace option' do
+          pending 'Impossible to test without real files'
+          File.should_receive(:new).with(anything, anything, hash_including(:replace))
+#         File.new(options[:file_name]||FILE_NAME, (options[:trunc] ? 'w:' : 'a:') +
+#                   (options[:file_encoding]||FILE_ENCODING), :undef => options[:undef]||:replace)
+          logger = RemoteLogger.create_logger #:replace=>'-'
+          logger_should_log '%Y-%m-%d %H:%M:\d{2}.\d{3} INFO My - message\n'
+          logger.info 'My 昔 message'
+        end
+
+        it 'skips logger creation announcement with :silent option'
+       end
+    end
+
+    context 'creating Drb logger' do
+      spec{ pending; use{  RemoteLogger.start_drb_logger(name = 'RemoteLogger', options = {})}}
+      it_should_behave_like 'Log4r proxy'
+
+      it 'instantiates drb logger service' do
+
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--color
+--format nested

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+lib_dir = File.join(File.dirname(__FILE__), "..", "lib" )
+$LOAD_PATH.unshift lib_dir unless $LOAD_PATH.include?(lib_dir)
+require 'remote_logger'
+
+# Module that extends RSpec with my own extensions/macros
+module SpecMacros
+
+  # Wrapper for *it* method that extracts description from example source code, such as:
+  # spec{ use{  result =  function(arg1 = 4, arg2 = 'string')  }}
+  def spec &block
+    it description_from(*block.source_location), &block
+  end
+
+  # reads description line from source file and drops external brackets (like *spec*{}, *use*{})
+  def description_from(file, line)
+    File.open(file) do |f|
+      f.lines.to_a[line-1].gsub( Regexp.new('(spec.*?{)|(use.*?{)|}'), '' ).lstrip.rstrip
+    end
+  end
+end
+
+Spec::Runner.configure { |config| config.extend(SpecMacros) }
+
+module RemoteLoggerTest
+
+  # Test related Constants:
+  TEST_NAME = 'MyLogger'
+  TEST_STRING = 'This is test string'
+
+  # Checks that given block does not raise any errors
+  def use
+    lambda {yield}.should_not raise_error
+  end
+
+  # Returns empty block (for use in spec descriptions)
+  def any_block
+    lambda {|*args| args}
+  end
+
+  # Sets expectations of receiving timestamped message on both logfile mock and stdout
+  def logger_should_log message
+    formatted_message = Time.now.strftime message
+#    logfile = mock('logfile').as_null_object
+#    File.stub(:new).and_return(logfile)
+    @logfile_mock.should_receive(:print).with(Regexp.new(formatted_message))
+    $stdout.should_receive(:print).with(Regexp.new(formatted_message))
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: remote_logger
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- arvicco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-22 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Remote logger based on Log4r
+email: arvitallian@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- features/remote_logger.feature
+- features/step_definitions/remote_logger_steps.rb
+- features/support/env.rb
+- lib/remote_logger.rb
+- lib/remote_logger/remote_logger.rb
+- spec/remote_logger/remote_logger_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/arvicco/remote_logger
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Remote logger based on Log4r
+test_files: 
+- spec/remote_logger/remote_logger_spec.rb
+- spec/spec_helper.rb