Free logging into software for linux

cx_Logging is a Python extension module which operates in a fashion similar to
the logging module that ships with Python 2.3 and higher. cx_Logging project also has a C interface which allows applications to perform logging independently of Python.

This project is being released to the public since other projects that are
available publicly depend on this module.

Please see the included documentation for additional information. Note that
the documentation is a work in progress. It is currently only suitable as
reference material but I intend to supplement this documentation over time.

Logging Services project is intended to provide cross-language logging services for purposes of application debugging and auditing.
We should also mention that thanks to the relentless efforts of many developers, we have a basic level of interoperability between the following projects:
- Log4Cxx (c++)
- Log4j
- Log4Net
- Log4Perl
- Log4PHP
- Log4PLSQL
- JDK1.4s util.logging framework
There is still much work ahead bringing in the various projects to work together within the Logging Services Project. The process is likely to take a little while. In the mean time, we will continue to do what we like best, that is developing open source software.
This is a project of the Apache Software Foundation (ASF). Like all Apache projects, we encourage a collaborative, consensus-based development process. We offer an open and pragmatic software license, and we strive to create software of the highest quality. The ASF is organized into several projects, which like Logging Services project may contain multiple sub-projects.

The Python logging module implements a standard logging system for Python programs. It was strongly influenced by log4j from the Apache project.

As this package is included in versions 2.3 and later, only users of earlier versions of Python would need to install this module.

There was a need for a standard logging system in Python, as comprehensively documented in PEP 282 and enthusiastically endorsed by the BDFL in the Parade of the PEPs.

By a happy coincidence, the package described here was already in development and fairly close in intent and design to the description in the aforementioned PEP, borrowing as it did heavily from JSR-47 (now JDK 1.4s java.util.logging package) and log4j.

This page describes it in more detail. As I have tweaked the package to meet comments on PEP 282, I have structured this page in the same way as the original PEP.

This package is now part of Python 2.3, but if you have an earlier version of Python, you can download the package from here and use it with Python versions between 1.5.2 and 2.2.x.

Xlog is a GTK+ Logging program for Hamradio Operators with rig control.

xlog is a logging program for amateur radio operators which can be used for dialy logging and contest. Xlog stores the logs into a text file.

QSOs are presented in a list. Items in the list can be added, deleted or updated. For each contact, dxcc information is displayed and bearings and distance is calculated, both short and long path.

When hamlib is enabled through the menu, you can retrieve frequency, mode and signal-strength from you rig over the serial port.

Lovi is a log file viewer for the K Desktop Environment. Lovi supports monitoring multiple log files, with color-coded filtering of warning and error messages.

Fast Logging Project for Snort is designed to gather alerts with payload from distributed snort sensors on a central server and to store them in a database (MySQL and PostgreSQL are supported).
On the sensor, the output is written to a process called sockserv. This process is threaded; one thread receives and buffers the alert packets, and the other thread forwards them to a central server.
The output is decoupled from snort, which can proceed in sniffing instead of waiting for the output plugins. At the central server, a process called servsock gathers all alerts from the remote sensors and feeds them to the database.
A short description of alerts with high priority together with the database ID can be sent via email to a list of recipients.
Main features:
- Decoupling of the output from snort. Snort can work on new packets instead of processing the output.
- Buffering of alerts on the sensor. This is useful if you have a shortage on your network to the central server or the servsock process on the central server is not running (maybe it will be restarted due to a change to a newer version...)
- Buffering of alerts on the central server. It is not uncommon that the database (especially MySQL) is hanging during a high input rate or the rate is faster than the database is able to store.
- Fast writing to the database via an unix domain socket.
- E-Mail alerting on high priority alerts.
- Drop feature for the worst case. At least the basic alert informations are still available either via E-Mail or on stdout/syslog.
- Since version 1.0.6 the alerts which should be dropped on the central server if servsock exits are written to a swap file. So this data is still availabe.
- If alerts have to been dropped because the high water mark was reached then these data are not written to the swap file.
Enhancements:
- Several checks were added, the alert data from Snort got a tag, and a restart of Snort is now checked.
- getpacket now has base 64 support.
- The statistics are now generated via the control thread so some signals are no longer necessary.
- The exit handler was rewritten and a cache for signatures was added.
- This cache can accelerate the insert rate by up to a factor of two and is implemented as a red black tree.
- During runtime, the only SELECT statement is for the signature ID, and all other operations are INSERT statements.
- The idea is to cache all signatures that caused an alert.

Simple Logging Facade for Java also know as SLF4J is intended to serve as a simple facade for various logging APIs, allowing to the end-user to plug in the desired implementation at deployment time.
Logging API implementations can either choose to implement the the SLF4J interfaces directly, e.g. NLOG4J or SimpleLogger. Alternatively, it is possible (and rather easy) to write SLF4J adapters for the given API implementation, e.g. Log4jLoggerAdapter or JDK14LoggerAdapter.
The SLF4J interfaces and their various adapters are simple and straightforward. Most developers familiar with the Java language should be able to read and fully understand the code in less than one hour.
SLF4J does not rely on any special class loader machinery. In fact, the binding between SLF4J and a given logging API implementation is performed statically at compile time.
Each binding is hardwired to use one and only specific logging API implementation. Thus, SLF4J suffers from none of the class loader problems or memory leaks observed with other approaches.
We hope that simplicity of the SLF4J interfaces and the deployment model will make it easy for developers of other logging APIs to conform to the SLF4J model.
Enhancements:
- This release consists of bugfixes only.
- Moreover, since the major packaging-related changes in 1.1.0-beta0 seem to work well, this release is marked as 1.1.0-RC0.

Log::Dispatch::ToTk provides class to redirect Log::Dispatch to Tk widgets.

Most users will only need to use Log::Dispatch::TkText widget to have Log::Dispatch messages written on a text widget.

For more fancy uses, this module can be used by a composite widget dedicated to handle Log::Dispatch logs.

This module is the interface class between Log::Dispatch and Tk widgets. This class is derived from Log::Dispatch::Output.

One ToTk object will be created for each Log::Dispatch::Tk* widget and the user must register the ToTk object to the log dispatcher.

Create a new ToTk object. Parameter are :
- widget ($) - The buddy widget object
- name ($) - The name of the object (not the filename!). Required.
- min_level ($) - The minimum logging level this object will accept. See the Log::Dispatch documentation for more information. Required.
- max_level ($) - The maximum logging level this obejct will accept. See the Log::Dispatch documentation for more information. This is not required. By default the maximum is the highest possible level (which means functionally that the object has no maximum).