summaryrefslogtreecommitdiff
path: root/jni/ruby/ext/syslog
diff options
context:
space:
mode:
authorJari Vetoniemi <jari.vetoniemi@indooratlas.com>2020-03-16 18:49:26 +0900
committerJari Vetoniemi <jari.vetoniemi@indooratlas.com>2020-03-30 00:39:06 +0900
commitfcbf63e62c627deae76c1b8cb8c0876c536ed811 (patch)
tree64cb17de3f41a2b6fef2368028fbd00349946994 /jni/ruby/ext/syslog
Fresh start
Diffstat (limited to 'jni/ruby/ext/syslog')
-rw-r--r--jni/ruby/ext/syslog/Makefile292
-rw-r--r--jni/ruby/ext/syslog/depend12
-rw-r--r--jni/ruby/ext/syslog/extconf.h6
-rw-r--r--jni/ruby/ext/syslog/extconf.rb10
-rw-r--r--jni/ruby/ext/syslog/lib/syslog/logger.rb208
-rw-r--r--jni/ruby/ext/syslog/syslog.c592
-rw-r--r--jni/ruby/ext/syslog/syslog.txt124
7 files changed, 1244 insertions, 0 deletions
diff --git a/jni/ruby/ext/syslog/Makefile b/jni/ruby/ext/syslog/Makefile
new file mode 100644
index 0000000..6e37fb7
--- /dev/null
+++ b/jni/ruby/ext/syslog/Makefile
@@ -0,0 +1,292 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose. other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@:)
+ECHO = $(ECHO1:0=@echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+top_srcdir = $(topdir)/.
+srcdir = $(top_srcdir)/ext/syslog
+topdir = ../..
+hdrdir = $(top_srcdir)/include
+arch_hdrdir = $(extout)/include/$(arch)
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+RUBYLIB =
+RUBYOPT = -
+prefix = $(DESTDIR)/usr/local
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-R$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+
+RUBY_EXTCONF_H = extconf.h
+cflags = $(optflags) $(debugflags) $(warnflags)
+optflags = -O3 -fno-fast-math
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wno-unused-parameter -Wno-parentheses -Wno-long-long -Wno-missing-field-initializers -Wunused-variable -Wpointer-arith -Wwrite-strings -Wdeclaration-after-statement -Wimplicit-function-declaration -Wdeprecated-declarations -Wno-packed-bitfield-compat
+CCDLFLAGS = -fPIC
+CFLAGS = $(CCDLFLAGS) $(cflags) -fPIC $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir)
+DEFS =
+CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
+ldflags = -L. -fstack-protector -rdynamic -Wl,-export-dynamic
+dldflags =
+ARCH_FLAG =
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT =
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME =
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.2.0
+ruby = $(topdir)/miniruby -I'$(topdir)' -I'$(top_srcdir)/lib' -I'$(extout)/$(arch)' -I'$(extout)/common'
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H)
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /bin/mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload =
+
+libpath = . $(topdir)
+LIBPATH = -L. -L$(topdir)
+DEFFILE =
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES =
+DISTCLEANDIRS =
+
+extout = $(topdir)/.ext
+extout_prefix = $(extout)$(target_prefix)/
+target_prefix =
+LOCAL_LIBS =
+LIBS = $(LIBRUBYARG_SHARED) -lpthread -lgmp -ldl -lcrypt -lm -lc
+ORIG_SRCS = syslog.c
+SRCS = $(ORIG_SRCS)
+OBJS = syslog.o
+HDRS = $(srcdir)/extconf.h
+TARGET = syslog
+TARGET_NAME = syslog
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC =
+STATIC_LIB = $(TARGET).a
+
+TIMESTAMP_DIR = $(extout)/.timestamp
+BINDIR = $(extout)/bin
+RUBYCOMMONDIR = $(extout)/common
+RUBYLIBDIR = $(RUBYCOMMONDIR)$(target_prefix)
+RUBYARCHDIR = $(extout)/$(arch)$(target_prefix)
+HDRDIR = $(extout)/include/ruby$(target_prefix)
+ARCHHDRDIR = $(extout)/include/$(arch)/ruby$(target_prefix)
+
+TARGET_SO = $(RUBYARCHDIR)/$(DLLIB)
+CLEANLIBS = $(RUBYARCHDIR)/$(TARGET).so
+CLEANOBJS = *.o *.bak
+
+all: install
+static: all
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+ -$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+ -$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+ -$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+ -$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+clean-so::
+ -$(Q)$(RM) $(RUBYARCHDIR)/$(DLLIB)
+ -$(Q)$(RMDIRS) $(RUBYARCHDIR) 2> /dev/null || true
+clean-static::
+ -$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+pre-install-rb-default: $(TIMESTAMP_DIR)/.RUBYLIBDIR.-.syslog.time
+install-rb-default: $(RUBYLIBDIR)/syslog/logger.rb
+$(RUBYLIBDIR)/syslog/logger.rb: $(srcdir)/lib/syslog/logger.rb $(TIMESTAMP_DIR)/.RUBYLIBDIR.-.syslog.time
+ $(Q) $(COPY) $(srcdir)/lib/syslog/logger.rb $(@D)
+clean-rb-default::
+ -$(Q)$(RM) $(RUBYLIBDIR)/syslog/logger.rb
+pre-install-rb-default:
+ $(ECHO) installing default syslog libraries
+clean-rb-default::
+ -$(Q)$(RMDIRS) $(RUBYLIBDIR)/syslog 2> /dev/null || true
+$(TIMESTAMP_DIR)/.RUBYARCHDIR.time:
+ $(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+ $(Q) $(TOUCH) $@
+$(TIMESTAMP_DIR)/.RUBYLIBDIR.-.syslog.time:
+ $(Q) $(MAKEDIRS) $(@D) $(RUBYLIBDIR)/syslog
+ $(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cc.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.mm.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.mm.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.cxx.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cxx.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.cpp.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $<
+
+.cpp.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $<
+
+.c.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.c.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
+
+.m.o:
+ $(ECHO) compiling $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $<
+
+.m.S:
+ $(ECHO) translating $(<)
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $<
+
+$(RUBYARCHDIR)/$(DLLIB): $(OBJS) Makefile $(TIMESTAMP_DIR)/.RUBYARCHDIR.time
+ $(ECHO) linking shared-object $(DLLIB)
+ -$(Q)$(RM) $(@)
+ $(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+$(STATIC_LIB): $(OBJS)
+ -$(Q)$(RM) $(@)
+ $(ECHO) linking static-library $(@)
+ $(Q) $(AR) cru $@ $(OBJS)
+ -$(Q)ranlib $(@) 2> /dev/null || true
+
+###
+$(OBJS): $(RUBY_EXTCONF_H)
+
+# AUTOGENERATED DEPENDENCIES START
+syslog.o: $(RUBY_EXTCONF_H)
+syslog.o: $(arch_hdrdir)/ruby/config.h
+syslog.o: $(hdrdir)/ruby/defines.h
+syslog.o: $(hdrdir)/ruby/intern.h
+syslog.o: $(hdrdir)/ruby/missing.h
+syslog.o: $(hdrdir)/ruby/ruby.h
+syslog.o: $(hdrdir)/ruby/st.h
+syslog.o: $(hdrdir)/ruby/subst.h
+syslog.o: $(hdrdir)/ruby/util.h
+syslog.o: syslog.c
+# AUTOGENERATED DEPENDENCIES END
diff --git a/jni/ruby/ext/syslog/depend b/jni/ruby/ext/syslog/depend
new file mode 100644
index 0000000..d818fd8
--- /dev/null
+++ b/jni/ruby/ext/syslog/depend
@@ -0,0 +1,12 @@
+# AUTOGENERATED DEPENDENCIES START
+syslog.o: $(RUBY_EXTCONF_H)
+syslog.o: $(arch_hdrdir)/ruby/config.h
+syslog.o: $(hdrdir)/ruby/defines.h
+syslog.o: $(hdrdir)/ruby/intern.h
+syslog.o: $(hdrdir)/ruby/missing.h
+syslog.o: $(hdrdir)/ruby/ruby.h
+syslog.o: $(hdrdir)/ruby/st.h
+syslog.o: $(hdrdir)/ruby/subst.h
+syslog.o: $(hdrdir)/ruby/util.h
+syslog.o: syslog.c
+# AUTOGENERATED DEPENDENCIES END
diff --git a/jni/ruby/ext/syslog/extconf.h b/jni/ruby/ext/syslog/extconf.h
new file mode 100644
index 0000000..1a962c0
--- /dev/null
+++ b/jni/ruby/ext/syslog/extconf.h
@@ -0,0 +1,6 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#define HAVE_SYSLOG_H 1
+#define HAVE_OPENLOG 1
+#define HAVE_SETLOGMASK 1
+#endif
diff --git a/jni/ruby/ext/syslog/extconf.rb b/jni/ruby/ext/syslog/extconf.rb
new file mode 100644
index 0000000..d1f68af
--- /dev/null
+++ b/jni/ruby/ext/syslog/extconf.rb
@@ -0,0 +1,10 @@
+# $RoughId: extconf.rb,v 1.3 2001/11/24 17:49:26 knu Exp $
+# $Id: extconf.rb 25189 2009-10-02 12:04:37Z akr $
+
+require 'mkmf'
+
+have_header("syslog.h") &&
+ have_func("openlog") &&
+ have_func("setlogmask") &&
+ create_makefile("syslog")
+
diff --git a/jni/ruby/ext/syslog/lib/syslog/logger.rb b/jni/ruby/ext/syslog/lib/syslog/logger.rb
new file mode 100644
index 0000000..7040e19
--- /dev/null
+++ b/jni/ruby/ext/syslog/lib/syslog/logger.rb
@@ -0,0 +1,208 @@
+require 'syslog'
+require 'logger'
+
+##
+# Syslog::Logger is a Logger work-alike that logs via syslog instead of to a
+# file. You can use Syslog::Logger to aggregate logs between multiple
+# machines.
+#
+# By default, Syslog::Logger uses the program name 'ruby', but this can be
+# changed via the first argument to Syslog::Logger.new.
+#
+# NOTE! You can only set the Syslog::Logger program name when you initialize
+# Syslog::Logger for the first time. This is a limitation of the way
+# Syslog::Logger uses syslog (and in some ways, a limitation of the way
+# syslog(3) works). Attempts to change Syslog::Logger's program name after
+# the first initialization will be ignored.
+#
+# === Example
+#
+# The following will log to syslogd on your local machine:
+#
+# require 'syslog/logger'
+#
+# log = Syslog::Logger.new 'my_program'
+# log.info 'this line will be logged via syslog(3)'
+#
+# Also the facility may be set to specify the facility level which will be used:
+#
+# log.info 'this line will be logged using Syslog default facility level'
+#
+# log_local1 = Syslog::Logger.new 'my_program', Syslog::LOG_LOCAL1
+# log_local1.info 'this line will be logged using local1 facility level'
+#
+#
+# You may need to perform some syslog.conf setup first. For a BSD machine add
+# the following lines to /etc/syslog.conf:
+#
+# !my_program
+# *.* /var/log/my_program.log
+#
+# Then touch /var/log/my_program.log and signal syslogd with a HUP
+# (killall -HUP syslogd, on FreeBSD).
+#
+# If you wish to have logs automatically roll over and archive, see the
+# newsyslog.conf(5) and newsyslog(8) man pages.
+
+class Syslog::Logger
+ # Default formatter for log messages.
+ class Formatter
+ def call severity, time, progname, msg
+ clean msg
+ end
+
+ private
+
+ ##
+ # Clean up messages so they're nice and pretty.
+
+ def clean message
+ message = message.to_s.strip
+ message.gsub!(/\e\[[0-9;]*m/, '') # remove useless ansi color codes
+ return message
+ end
+ end
+
+ ##
+ # The version of Syslog::Logger you are using.
+
+ VERSION = '2.1.0'
+
+ ##
+ # Maps Logger warning types to syslog(3) warning types.
+ #
+ # Messages from Ruby applications are not considered as critical as messages
+ # from other system daemons using syslog(3), so most messages are reduced by
+ # one level. For example, a fatal message for Ruby's Logger is considered
+ # an error for syslog(3).
+
+ LEVEL_MAP = {
+ ::Logger::UNKNOWN => Syslog::LOG_ALERT,
+ ::Logger::FATAL => Syslog::LOG_ERR,
+ ::Logger::ERROR => Syslog::LOG_WARNING,
+ ::Logger::WARN => Syslog::LOG_NOTICE,
+ ::Logger::INFO => Syslog::LOG_INFO,
+ ::Logger::DEBUG => Syslog::LOG_DEBUG,
+ }
+
+ ##
+ # Returns the internal Syslog object that is initialized when the
+ # first instance is created.
+
+ def self.syslog
+ @@syslog
+ end
+
+ ##
+ # Specifies the internal Syslog object to be used.
+
+ def self.syslog= syslog
+ @@syslog = syslog
+ end
+
+ ##
+ # Builds a methods for level +meth+.
+
+ def self.make_methods meth
+ level = ::Logger.const_get(meth.upcase)
+ eval <<-EOM, nil, __FILE__, __LINE__ + 1
+ def #{meth}(message = nil, &block)
+ add(#{level}, message, &block)
+ end
+
+ def #{meth}?
+ @level <= #{level}
+ end
+ EOM
+ end
+
+ ##
+ # :method: unknown
+ #
+ # Logs a +message+ at the unknown (syslog alert) log level, or logs the
+ # message returned from the block.
+
+ ##
+ # :method: fatal
+ #
+ # Logs a +message+ at the fatal (syslog err) log level, or logs the message
+ # returned from the block.
+
+ ##
+ # :method: error
+ #
+ # Logs a +message+ at the error (syslog warning) log level, or logs the
+ # message returned from the block.
+
+ ##
+ # :method: warn
+ #
+ # Logs a +message+ at the warn (syslog notice) log level, or logs the
+ # message returned from the block.
+
+ ##
+ # :method: info
+ #
+ # Logs a +message+ at the info (syslog info) log level, or logs the message
+ # returned from the block.
+
+ ##
+ # :method: debug
+ #
+ # Logs a +message+ at the debug (syslog debug) log level, or logs the
+ # message returned from the block.
+
+ Logger::Severity::constants.each do |severity|
+ make_methods severity.downcase
+ end
+
+ ##
+ # Log level for Logger compatibility.
+
+ attr_accessor :level
+
+ # Logging formatter, as a +Proc+ that will take four arguments and
+ # return the formatted message. The arguments are:
+ #
+ # +severity+:: The Severity of the log message.
+ # +time+:: A Time instance representing when the message was logged.
+ # +progname+:: The #progname configured, or passed to the logger method.
+ # +msg+:: The _Object_ the user passed to the log message; not necessarily a
+ # String.
+ #
+ # The block should return an Object that can be written to the logging
+ # device via +write+. The default formatter is used when no formatter is
+ # set.
+ attr_accessor :formatter
+
+ ##
+ # The facility argument is used to specify what type of program is logging the message.
+
+ attr_accessor :facility
+
+ ##
+ # Fills in variables for Logger compatibility. If this is the first
+ # instance of Syslog::Logger, +program_name+ may be set to change the logged
+ # program name. The +facility+ may be set to specify the facility level which will be used.
+ #
+ # Due to the way syslog works, only one program name may be chosen.
+
+ def initialize program_name = 'ruby', facility = nil
+ @level = ::Logger::DEBUG
+ @formatter = Formatter.new
+
+ @@syslog ||= Syslog.open(program_name)
+
+ @facility = (facility || @@syslog.facility)
+ end
+
+ ##
+ # Almost duplicates Logger#add. +progname+ is ignored.
+
+ def add severity, message = nil, progname = nil, &block
+ severity ||= ::Logger::UNKNOWN
+ @level <= severity and
+ @@syslog.log( (LEVEL_MAP[severity] | @facility), '%s', formatter.call(severity, Time.now, progname, (message || block.call)) )
+ true
+ end
+end
diff --git a/jni/ruby/ext/syslog/syslog.c b/jni/ruby/ext/syslog/syslog.c
new file mode 100644
index 0000000..4e4e281
--- /dev/null
+++ b/jni/ruby/ext/syslog/syslog.c
@@ -0,0 +1,592 @@
+/*
+ * UNIX Syslog extension for Ruby
+ * Amos Gouaux, University of Texas at Dallas
+ * <amos+ruby@utdallas.edu>
+ * Documented by mathew <meta@pobox.com>
+ *
+ * $RoughId: syslog.c,v 1.21 2002/02/25 12:21:17 knu Exp $
+ * $Id: syslog.c 47792 2014-10-04 23:09:32Z nobu $
+ */
+
+#include "ruby/ruby.h"
+#include "ruby/util.h"
+#include <syslog.h>
+
+/* Syslog class */
+static VALUE mSyslog;
+/*
+ * Module holding all Syslog constants. See Syslog::log and
+ * Syslog::open for constant descriptions.
+ */
+static VALUE mSyslogConstants;
+/* Module holding Syslog option constants */
+static VALUE mSyslogOption;
+/* Module holding Syslog facility constants */
+static VALUE mSyslogFacility;
+/* Module holding Syslog level constants */
+static VALUE mSyslogLevel;
+/* Module holding Syslog utility macros */
+static VALUE mSyslogMacros;
+
+static const char *syslog_ident = NULL;
+static int syslog_options = -1, syslog_facility = -1, syslog_mask = -1;
+static int syslog_opened = 0;
+
+/* Package helper routines */
+static void syslog_write(int pri, int argc, VALUE *argv)
+{
+ VALUE str;
+
+ if (argc < 1) {
+ rb_raise(rb_eArgError, "no log message supplied");
+ }
+
+ if (!syslog_opened) {
+ rb_raise(rb_eRuntimeError, "must open syslog before write");
+ }
+
+ str = rb_f_sprintf(argc, argv);
+
+ syslog(pri, "%s", RSTRING_PTR(str));
+}
+
+/* Closes the syslog facility.
+ * Raises a runtime exception if it is not open.
+ */
+static VALUE mSyslog_close(VALUE self)
+{
+ if (!syslog_opened) {
+ rb_raise(rb_eRuntimeError, "syslog not opened");
+ }
+
+ closelog();
+
+ xfree((void *)syslog_ident);
+ syslog_ident = NULL;
+ syslog_options = syslog_facility = syslog_mask = -1;
+ syslog_opened = 0;
+
+ return Qnil;
+}
+
+/* call-seq:
+ * open(ident, options, facility) => syslog
+ *
+ * :yields: syslog
+ *
+ * Open the syslog facility.
+ * Raises a runtime exception if it is already open.
+ *
+ * Can be called with or without a code block. If called with a block, the
+ * Syslog object created is passed to the block.
+ *
+ * If the syslog is already open, raises a RuntimeError.
+ *
+ * +ident+ is a String which identifies the calling program.
+ *
+ * +options+ is the logical OR of any of the following:
+ *
+ * LOG_CONS:: If there is an error while sending to the system logger,
+ * write directly to the console instead.
+ *
+ * LOG_NDELAY:: Open the connection now, rather than waiting for the first
+ * message to be written.
+ *
+ * LOG_NOWAIT:: Don't wait for any child processes created while logging
+ * messages. (Has no effect on Linux.)
+ *
+ * LOG_ODELAY:: Opposite of LOG_NDELAY; wait until a message is sent before
+ * opening the connection. (This is the default.)
+ *
+ * LOG_PERROR:: Print the message to stderr as well as sending it to syslog.
+ * (Not in POSIX.1-2001.)
+ *
+ * LOG_PID:: Include the current process ID with each message.
+ *
+ * +facility+ describes the type of program opening the syslog, and is
+ * the logical OR of any of the following which are defined for the host OS:
+ *
+ * LOG_AUTH:: Security or authorization. Deprecated, use LOG_AUTHPRIV
+ * instead.
+ *
+ * LOG_AUTHPRIV:: Security or authorization messages which should be kept
+ * private.
+ *
+ * LOG_CONSOLE:: System console message.
+ *
+ * LOG_CRON:: System task scheduler (cron or at).
+ *
+ * LOG_DAEMON:: A system daemon which has no facility value of its own.
+ *
+ * LOG_FTP:: An FTP server.
+ *
+ * LOG_KERN:: A kernel message (not sendable by user processes, so not of
+ * much use to Ruby, but listed here for completeness).
+ *
+ * LOG_LPR:: Line printer subsystem.
+ *
+ * LOG_MAIL:: Mail delivery or transport subsystem.
+ *
+ * LOG_NEWS:: Usenet news system.
+ *
+ * LOG_NTP:: Network Time Protocol server.
+ *
+ * LOG_SECURITY:: General security message.
+ *
+ * LOG_SYSLOG:: Messages generated internally by syslog.
+ *
+ * LOG_USER:: Generic user-level message.
+ *
+ * LOG_UUCP:: UUCP subsystem.
+ *
+ * LOG_LOCAL0 to LOG_LOCAL7:: Locally-defined facilities.
+ *
+ * Example:
+ *
+ * Syslog.open("webrick", Syslog::LOG_PID,
+ * Syslog::LOG_DAEMON | Syslog::LOG_LOCAL3)
+ *
+ */
+static VALUE mSyslog_open(int argc, VALUE *argv, VALUE self)
+{
+ VALUE ident, opt, fac;
+
+ if (syslog_opened) {
+ rb_raise(rb_eRuntimeError, "syslog already open");
+ }
+
+ rb_scan_args(argc, argv, "03", &ident, &opt, &fac);
+
+ if (NIL_P(ident)) {
+ ident = rb_gv_get("$0");
+ }
+ SafeStringValue(ident);
+ syslog_ident = strdup(RSTRING_PTR(ident));
+
+ if (NIL_P(opt)) {
+ syslog_options = LOG_PID | LOG_CONS;
+ } else {
+ syslog_options = NUM2INT(opt);
+ }
+
+ if (NIL_P(fac)) {
+ syslog_facility = LOG_USER;
+ } else {
+ syslog_facility = NUM2INT(fac);
+ }
+
+ openlog(syslog_ident, syslog_options, syslog_facility);
+
+ syslog_opened = 1;
+
+ setlogmask(syslog_mask = setlogmask(0));
+
+ /* be like File.new.open {...} */
+ if (rb_block_given_p()) {
+ rb_ensure(rb_yield, self, mSyslog_close, self);
+ }
+
+ return self;
+}
+
+/* call-seq:
+ * reopen(ident, options, facility) => syslog
+ *
+ * :yields: syslog
+ *
+ * Closes and then reopens the syslog.
+ *
+ * Arguments are the same as for open().
+ */
+static VALUE mSyslog_reopen(int argc, VALUE *argv, VALUE self)
+{
+ mSyslog_close(self);
+
+ return mSyslog_open(argc, argv, self);
+}
+
+/* call-seq:
+ * opened?
+ *
+ * Returns true if the syslog is open.
+ */
+static VALUE mSyslog_isopen(VALUE self)
+{
+ return syslog_opened ? Qtrue : Qfalse;
+}
+
+/* Returns the identity string used in the last call to open()
+ */
+static VALUE mSyslog_ident(VALUE self)
+{
+ return syslog_opened ? rb_str_new2(syslog_ident) : Qnil;
+}
+
+/* Returns the options bitmask used in the last call to open()
+ */
+static VALUE mSyslog_options(VALUE self)
+{
+ return syslog_opened ? INT2NUM(syslog_options) : Qnil;
+}
+
+/* Returns the facility number used in the last call to open()
+ */
+static VALUE mSyslog_facility(VALUE self)
+{
+ return syslog_opened ? INT2NUM(syslog_facility) : Qnil;
+}
+
+/* Returns the log priority mask in effect. The mask is not reset by opening
+ * or closing syslog.
+ */
+static VALUE mSyslog_get_mask(VALUE self)
+{
+ return syslog_opened ? INT2NUM(syslog_mask) : Qnil;
+}
+
+/* call-seq:
+ * mask=(priority_mask)
+ *
+ * Sets the log priority mask. A method LOG_UPTO is defined to make it easier
+ * to set mask values. Example:
+ *
+ * Syslog.mask = Syslog::LOG_UPTO(Syslog::LOG_ERR)
+ *
+ * Alternatively, specific priorities can be selected and added together using
+ * binary OR. Example:
+ *
+ * Syslog.mask = Syslog::LOG_MASK(Syslog::LOG_ERR) | Syslog::LOG_MASK(Syslog::LOG_CRIT)
+ *
+ * The priority mask persists through calls to open() and close().
+ */
+static VALUE mSyslog_set_mask(VALUE self, VALUE mask)
+{
+ if (!syslog_opened) {
+ rb_raise(rb_eRuntimeError, "must open syslog before setting log mask");
+ }
+
+ setlogmask(syslog_mask = NUM2INT(mask));
+
+ return mask;
+}
+
+/* call-seq:
+ * log(priority, format_string, *format_args)
+ *
+ * Log a message with the specified priority. Example:
+ *
+ * Syslog.log(Syslog::LOG_CRIT, "Out of disk space")
+ * Syslog.log(Syslog::LOG_CRIT, "User %s logged in", ENV['USER'])
+ *
+ * The priority levels, in descending order, are:
+ *
+ * LOG_EMERG:: System is unusable
+ * LOG_ALERT:: Action needs to be taken immediately
+ * LOG_CRIT:: A critical condition has occurred
+ * LOG_ERR:: An error occurred
+ * LOG_WARNING:: Warning of a possible problem
+ * LOG_NOTICE:: A normal but significant condition occurred
+ * LOG_INFO:: Informational message
+ * LOG_DEBUG:: Debugging information
+ *
+ * Each priority level also has a shortcut method that logs with it's named priority.
+ * As an example, the two following statements would produce the same result:
+ *
+ * Syslog.log(Syslog::LOG_ALERT, "Out of memory")
+ * Syslog.alert("Out of memory")
+ *
+ * Format strings are as for printf/sprintf, except that in addition %m is
+ * replaced with the error message string that would be returned by
+ * strerror(errno).
+ *
+ */
+static VALUE mSyslog_log(int argc, VALUE *argv, VALUE self)
+{
+ VALUE pri;
+
+ if (argc < 2) {
+ rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", argc);
+ }
+
+ argc--;
+ pri = *argv++;
+
+ if (!FIXNUM_P(pri)) {
+ rb_raise(rb_eTypeError, "type mismatch: %"PRIsVALUE" given", rb_obj_class(pri));
+ }
+
+ syslog_write(FIX2INT(pri), argc, argv);
+
+ return self;
+}
+
+/* Returns an inspect() string summarizing the object state.
+ */
+static VALUE mSyslog_inspect(VALUE self)
+{
+ Check_Type(self, T_MODULE);
+
+ if (!syslog_opened)
+ return rb_sprintf("<#%"PRIsVALUE": opened=false>", self);
+
+ return rb_sprintf("<#%"PRIsVALUE": opened=true, ident=\"%s\", options=%d, facility=%d, mask=%d>",
+ self,
+ syslog_ident,
+ syslog_options,
+ syslog_facility,
+ syslog_mask);
+}
+
+/* Returns self, for backward compatibility.
+ */
+static VALUE mSyslog_instance(VALUE self)
+{
+ return self;
+}
+
+#define define_syslog_shortcut_method(pri, name) \
+static VALUE mSyslog_##name(int argc, VALUE *argv, VALUE self) \
+{ \
+ syslog_write((pri), argc, argv); \
+\
+ return self; \
+}
+
+#ifdef LOG_EMERG
+define_syslog_shortcut_method(LOG_EMERG, emerg)
+#endif
+#ifdef LOG_ALERT
+define_syslog_shortcut_method(LOG_ALERT, alert)
+#endif
+#ifdef LOG_CRIT
+define_syslog_shortcut_method(LOG_CRIT, crit)
+#endif
+#ifdef LOG_ERR
+define_syslog_shortcut_method(LOG_ERR, err)
+#endif
+#ifdef LOG_WARNING
+define_syslog_shortcut_method(LOG_WARNING, warning)
+#endif
+#ifdef LOG_NOTICE
+define_syslog_shortcut_method(LOG_NOTICE, notice)
+#endif
+#ifdef LOG_INFO
+define_syslog_shortcut_method(LOG_INFO, info)
+#endif
+#ifdef LOG_DEBUG
+define_syslog_shortcut_method(LOG_DEBUG, debug)
+#endif
+
+/* call-seq:
+ * LOG_MASK(priority_level) => priority_mask
+ *
+ * Generates a mask bit for a priority level. See #mask=
+ */
+static VALUE mSyslogMacros_LOG_MASK(VALUE mod, VALUE pri)
+{
+ return INT2FIX(LOG_MASK(NUM2INT(pri)));
+}
+
+/* call-seq:
+ * LOG_UPTO(priority_level) => priority_mask
+ *
+ * Generates a mask value for priority levels at or below the level specified.
+ * See #mask=
+ */
+static VALUE mSyslogMacros_LOG_UPTO(VALUE mod, VALUE pri)
+{
+ return INT2FIX(LOG_UPTO(NUM2INT(pri)));
+}
+
+static VALUE mSyslogMacros_included(VALUE mod, VALUE target)
+{
+ rb_extend_object(target, mSyslogMacros);
+ return mod;
+}
+
+/* The syslog package provides a Ruby interface to the POSIX system logging
+ * facility.
+ *
+ * Syslog messages are typically passed to a central logging daemon.
+ * The daemon may filter them; route them into different files (usually
+ * found under /var/log); place them in SQL databases; forward
+ * them to centralized logging servers via TCP or UDP; or even alert the
+ * system administrator via email, pager or text message.
+ *
+ * Unlike application-level logging via Logger or Log4r, syslog is designed
+ * to allow secure tamper-proof logging.
+ *
+ * The syslog protocol is standardized in RFC 5424.
+ */
+void Init_syslog(void)
+{
+ mSyslog = rb_define_module("Syslog");
+
+ mSyslogConstants = rb_define_module_under(mSyslog, "Constants");
+
+ mSyslogOption = rb_define_module_under(mSyslog, "Option");
+ mSyslogFacility = rb_define_module_under(mSyslog, "Facility");
+ mSyslogLevel = rb_define_module_under(mSyslog, "Level");
+ mSyslogMacros = rb_define_module_under(mSyslog, "Macros");
+
+ rb_define_module_function(mSyslog, "open", mSyslog_open, -1);
+ rb_define_module_function(mSyslog, "reopen", mSyslog_reopen, -1);
+ rb_define_module_function(mSyslog, "open!", mSyslog_reopen, -1);
+ rb_define_module_function(mSyslog, "opened?", mSyslog_isopen, 0);
+
+ rb_define_module_function(mSyslog, "ident", mSyslog_ident, 0);
+ rb_define_module_function(mSyslog, "options", mSyslog_options, 0);
+ rb_define_module_function(mSyslog, "facility", mSyslog_facility, 0);
+
+ rb_define_module_function(mSyslog, "log", mSyslog_log, -1);
+ rb_define_module_function(mSyslog, "close", mSyslog_close, 0);
+ rb_define_module_function(mSyslog, "mask", mSyslog_get_mask, 0);
+ rb_define_module_function(mSyslog, "mask=", mSyslog_set_mask, 1);
+
+ rb_define_singleton_method(mSyslog, "inspect", mSyslog_inspect, 0);
+ rb_define_module_function(mSyslog, "instance", mSyslog_instance, 0);
+
+ /* Syslog options */
+
+#define rb_define_syslog_option(c) \
+ rb_define_const(mSyslogOption, #c, INT2NUM(c))
+
+#ifdef LOG_PID
+ rb_define_syslog_option(LOG_PID);
+#endif
+#ifdef LOG_CONS
+ rb_define_syslog_option(LOG_CONS);
+#endif
+#ifdef LOG_ODELAY
+ rb_define_syslog_option(LOG_ODELAY); /* deprecated */
+#endif
+#ifdef LOG_NDELAY
+ rb_define_syslog_option(LOG_NDELAY);
+#endif
+#ifdef LOG_NOWAIT
+ rb_define_syslog_option(LOG_NOWAIT); /* deprecated */
+#endif
+#ifdef LOG_PERROR
+ rb_define_syslog_option(LOG_PERROR);
+#endif
+
+ /* Syslog facilities */
+
+#define rb_define_syslog_facility(c) \
+ rb_define_const(mSyslogFacility, #c, INT2NUM(c))
+
+#ifdef LOG_AUTH
+ rb_define_syslog_facility(LOG_AUTH);
+#endif
+#ifdef LOG_AUTHPRIV
+ rb_define_syslog_facility(LOG_AUTHPRIV);
+#endif
+#ifdef LOG_CONSOLE
+ rb_define_syslog_facility(LOG_CONSOLE);
+#endif
+#ifdef LOG_CRON
+ rb_define_syslog_facility(LOG_CRON);
+#endif
+#ifdef LOG_DAEMON
+ rb_define_syslog_facility(LOG_DAEMON);
+#endif
+#ifdef LOG_FTP
+ rb_define_syslog_facility(LOG_FTP);
+#endif
+#ifdef LOG_KERN
+ rb_define_syslog_facility(LOG_KERN);
+#endif
+#ifdef LOG_LPR
+ rb_define_syslog_facility(LOG_LPR);
+#endif
+#ifdef LOG_MAIL
+ rb_define_syslog_facility(LOG_MAIL);
+#endif
+#ifdef LOG_NEWS
+ rb_define_syslog_facility(LOG_NEWS);
+#endif
+#ifdef LOG_NTP
+ rb_define_syslog_facility(LOG_NTP);
+#endif
+#ifdef LOG_SECURITY
+ rb_define_syslog_facility(LOG_SECURITY);
+#endif
+#ifdef LOG_SYSLOG
+ rb_define_syslog_facility(LOG_SYSLOG);
+#endif
+#ifdef LOG_USER
+ rb_define_syslog_facility(LOG_USER);
+#endif
+#ifdef LOG_UUCP
+ rb_define_syslog_facility(LOG_UUCP);
+#endif
+#ifdef LOG_LOCAL0
+ rb_define_syslog_facility(LOG_LOCAL0);
+#endif
+#ifdef LOG_LOCAL1
+ rb_define_syslog_facility(LOG_LOCAL1);
+#endif
+#ifdef LOG_LOCAL2
+ rb_define_syslog_facility(LOG_LOCAL2);
+#endif
+#ifdef LOG_LOCAL3
+ rb_define_syslog_facility(LOG_LOCAL3);
+#endif
+#ifdef LOG_LOCAL4
+ rb_define_syslog_facility(LOG_LOCAL4);
+#endif
+#ifdef LOG_LOCAL5
+ rb_define_syslog_facility(LOG_LOCAL5);
+#endif
+#ifdef LOG_LOCAL6
+ rb_define_syslog_facility(LOG_LOCAL6);
+#endif
+#ifdef LOG_LOCAL7
+ rb_define_syslog_facility(LOG_LOCAL7);
+#endif
+
+ /* Syslog levels and the shortcut methods */
+
+#define rb_define_syslog_level(c, m) \
+ rb_define_const(mSyslogLevel, #c, INT2NUM(c)); \
+ rb_define_module_function(mSyslog, #m, mSyslog_##m, -1)
+
+#ifdef LOG_EMERG
+ rb_define_syslog_level(LOG_EMERG, emerg);
+#endif
+#ifdef LOG_ALERT
+ rb_define_syslog_level(LOG_ALERT, alert);
+#endif
+#ifdef LOG_CRIT
+ rb_define_syslog_level(LOG_CRIT, crit);
+#endif
+#ifdef LOG_ERR
+ rb_define_syslog_level(LOG_ERR, err);
+#endif
+#ifdef LOG_WARNING
+ rb_define_syslog_level(LOG_WARNING, warning);
+#endif
+#ifdef LOG_NOTICE
+ rb_define_syslog_level(LOG_NOTICE, notice);
+#endif
+#ifdef LOG_INFO
+ rb_define_syslog_level(LOG_INFO, info);
+#endif
+#ifdef LOG_DEBUG
+ rb_define_syslog_level(LOG_DEBUG, debug);
+#endif
+
+ /* Syslog macros */
+
+ rb_define_method(mSyslogMacros, "LOG_MASK", mSyslogMacros_LOG_MASK, 1);
+ rb_define_method(mSyslogMacros, "LOG_UPTO", mSyslogMacros_LOG_UPTO, 1);
+ rb_define_singleton_method(mSyslogMacros, "included", mSyslogMacros_included, 1);
+
+ rb_include_module(mSyslogConstants, mSyslogOption);
+ rb_include_module(mSyslogConstants, mSyslogFacility);
+ rb_include_module(mSyslogConstants, mSyslogLevel);
+ rb_funcall(mSyslogConstants, rb_intern("include"), 1, mSyslogMacros);
+
+ rb_define_singleton_method(mSyslogConstants, "included", mSyslogMacros_included, 1);
+ rb_funcall(mSyslog, rb_intern("include"), 1, mSyslogConstants);
+}
diff --git a/jni/ruby/ext/syslog/syslog.txt b/jni/ruby/ext/syslog/syslog.txt
new file mode 100644
index 0000000..4286f29
--- /dev/null
+++ b/jni/ruby/ext/syslog/syslog.txt
@@ -0,0 +1,124 @@
+.\" syslog.txt - -*- Indented-Text -*-
+$RoughId: syslog.txt,v 1.18 2002/02/25 08:20:14 knu Exp $
+$Id: syslog.txt 31689 2011-05-22 09:26:02Z nobu $
+
+UNIX Syslog extension for Ruby
+Amos Gouaux, University of Texas at Dallas
+<amos+ruby@utdallas.edu>
+&
+Akinori MUSHA
+<knu@iDaemons.org>
+
+Contact:
+ - Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+
+** Syslog(Module)
+
+Included Modules: Syslog::Constants
+
+require 'syslog'
+
+A Simple wrapper for the UNIX syslog system calls that might be handy
+if you're writing a server in Ruby. For the details of the syslog(8)
+architecture and constants, see the syslog(3) manual page of your
+platform.
+
+Module Methods:
+
+ open(ident = $0, logopt = Syslog::LOG_PID | Syslog::LOG_CONS,
+ facility = Syslog::LOG_USER) [{ |syslog| ... }]
+
+ Opens syslog with the given options and returns the module
+ itself. If a block is given, calls it with an argument of
+ itself. If syslog is already opened, raises RuntimeError.
+
+ Example:
+ Syslog.open('ftpd', Syslog::LOG_PID | Syslog::LOG_NDELAY,
+ Syslog::LOG_FTP)
+
+ open!(ident = $0, logopt = Syslog::LOG_PID | Syslog::LOG_CONS,
+ facility = Syslog::LOG_USER)
+ reopen(ident = $0, logopt = Syslog::LOG_PID | Syslog::LOG_CONS,
+ facility = Syslog::LOG_USER)
+
+ Same as open, but does a close first.
+
+ opened?
+
+ Returns true if syslog opened, otherwise false.
+
+ ident
+ options
+ facility
+
+ Returns the parameters given in the last open, respectively.
+ Every call of Syslog::open resets these values.
+
+ log(pri, message, ...)
+
+ Writes message to syslog.
+
+ Example:
+ Syslog.log(Syslog::LOG_CRIT, "the sky is falling in %d seconds!", 10)
+
+ crit(message, ...)
+ emerg(message, ...)
+ alert(message, ...)
+ err(message, ...)
+ warning(message, ...)
+ notice(message, ...)
+ info(message, ...)
+ debug(message, ...)
+
+ These are shortcut methods of Syslog::log(). The lineup may
+ vary depending on what priorities are defined on your system.
+
+ Example:
+ Syslog.crit("the sky is falling in %d seconds!", 5)
+
+ mask
+ mask=(mask)
+
+ Returns or sets the log priority mask. The value of the mask
+ is persistent and will not be reset by Syslog::open or
+ Syslog::close.
+
+ Example:
+ Syslog.mask = Syslog::LOG_UPTO(Syslog::LOG_ERR)
+
+ close
+
+ Closes syslog.
+
+ inspect
+
+ Returns the "inspect" string of the Syslog module.
+
+ instance
+
+ Returns the module itself. (Just for backward compatibility)
+
+ LOG_MASK(pri)
+
+ Creates a mask for one priority.
+
+ LOG_UPTO(pri)
+
+ Creates a mask for all priorities up to pri.
+
+** Syslog::Constants(Module)
+
+require 'syslog'
+include Syslog::Constants
+
+This module includes the LOG_* constants available on the system.
+
+Module Methods:
+
+ LOG_MASK(pri)
+
+ Creates a mask for one priority.
+
+ LOG_UPTO(pri)
+
+ Creates a mask for all priorities up to pri.