Projects tagged ‘logger’ and ‘logging’

Octopussy is a solution to manage your logs (also frequently called a SIM/SEM/SIEM Solution). Basically, it stores your logs, produces reports, and raises alerts.

Python logging support for web developers. This is logging console integrated into Firebug. Ruby support is planned.

OverviewMinLog is a Java logging library. Key features: Low overhead Logging statements below a given level can be automatically removed by javac at compile time. Simple and efficient The API is ... [More] concise and very efficient at runtime. Extremely lightweight The entire project consists of one Java file with just over 100 non-comment lines of code. The JAR is 2.6kb (2kb with pack200). UsageMessages are logged using static methods: Log.info("Some message."); Log.debug("Error reading file: " + file, ex);A static import can be used to make the logging more concise: import static com.esotericsoftware.minlog.Log.*; // ... info("Some message."); debug("Error reading file: " + file, ex);While optional, for brevity the rest of this documentation assumes this static import is in place. If log statements from different libraries or areas of an application need to be differentiated, a category can be specified: info("some lib", "Some message."); debug("some lib", "Error reading file: " + file, ex);Log levelSetting the level will log that level, as well as all higher levels: Log.set(LEVEL_INFO);The levels are: LEVEL_NONE disables all logging. LEVEL_ERROR is for critical errors. The application may no longer work correctly. LEVEL_WARN is for important warnings. The application will continue to work correctly. LEVEL_INFO is for informative messages. Typically used for deployment. LEVEL_DEBUG is for debug messages. This level is useful during development. LEVEL_TRACE is for trace messages. A lot of information is logged, so this level is usually only needed when debugging a problem. Conditional loggingThe current log level can be checked before the message is logged: if (ERROR) error("Error reading file: " + file, ex); if (TRACE) { StringBuilder builder = new StringBuilder(); // Do work, append to the builder. trace(builder); }Checking the log level before calling the logging method is optional, but prevents unnecessary method calls and string concatenation for log levels that are disabled. Fixed logging levelsMinLog users can choose from the regular "minlog.jar" or from from a JAR file like "minlog-info.jar" which has a fixed logging level that cannot be changed at runtime (calls to Log.set() have no affect). During compilation, any conditional logging statements below the fixed level will be automatically optimized away by the Java compiler. Please see OverheadAndComparisons for more about the overhead when using MinLog with/without conditional logging and with/without a fixed logging level. The document also compares the MinLog overhead with log4j and java.util.logging. Output customizationThe default logger outputs messages in this format: time level: [category] messageWhere "time" is the time elapsed since the application started. For example: 00:00 TRACE: [kryo] Wrote string: moo 00:00 TRACE: [kryo] Wrote object: NonNullTestClass 00:01 TRACE: [kryo] Wrote string: this is some data 00:01 TRACE: [kryo] Compressed to 7.97% using: DeflateCompressor 00:12 TRACE: [kryo] Decompressed using: DeflateCompressor 00:12 TRACE: [kryo] Read string: this is some dataThe output can be customized: static public class MyLogger extends Logger { public void log (int level, String category, String message, Throwable ex) { StringBuilder builder = new StringBuilder(256); builder.append(new Date()); builder.append(' '); builder.append(level); builder.append('['); builder.append(category); builder.append("] "); builder.append(message); if (ex != null) { StringWriter writer = new StringWriter(256); ex.printStackTrace(new PrintWriter(writer)); builder.append('\n'); builder.append(writer.toString().trim()); } System.out.println(builder); } } // ... Log.set(new MyLogger());Using this mechanism, log messages can be filtered (eg, by category), written to a file, etc. [Less]

Log5F this is Logging Framework for Flash/Flex/AIR based application. It writen on ActionScript 3.0, during writing the code was analysed Log4J Logging Framework for Java. See http://log5f.wordpress.com

Tired of using window.alert() for all your debugging? This is a a simple yet useful logging framework for javascript. The output 'console' is a new window that is opened and printed to. There are 6 ... [More] levels of logging and different CSS styles can be applied to each level. [Less]

A simple Logging Library for .NET 3.5.

SpringTail is a simple Logging Framework Abstraction library for Silverlight 2 and .net. It provides a separation of your logging code from a logging framework. This enables you to select a logging ... [More] backend most suitable for your type of application without modifying your source. [Less]

JmxLoggerJmxLogger makes it easy to broadcast your Java Util Logging or your Log4J log events as JMX notifications. The JmxLogger API provides a Java Util Logging Handler and a Log4J Appender which ... [More] provides integration points between your favorite logging framework and JMX. JmxLogger hides the complexity of dealing with JMX. You simply configure your logging framework as you normally do, and that's it. You are ready to broadcast your logging events as JMX notification events. FeaturesSupport for Java Util Logging API Support for the Log4J logging API Easy integration with your favorite logging framework No coding required, simply configure your logging framework to get started. Specify and control the level of event to broadcast Monitor event through a console or listener scripts Getting StartedDownload the jar (generic or with log4j support) Add jar to your classpath Configure your favorite logging framework and you set Java Logging HandlerIf you are a user of the Java util Logging API, you should already be familiar on how to configure (declaratively or programmatically) the framwork for logging. Below is a sample of what your configuration file would look like when configuring JmxLogger's Handler class. The handler is configured like any other Java Logging handler. Notice that the handler supports several attributes which can be specified in the logging properties file. Missing attributes are automatically assigned a default value. So, you can have a blank configuration if you wanted to (as long as the Handler is declared). handlers=jmxlogger.integration.logutil.JmxLogHandler, java.util.logging.ConsoleHandler # Default global logging level. .level=INFO # jmx log handler jmxlogger.Handler.level=INFO jmxlogger.Handler.filter= jmxlogger.Handler.logPattern= jmxlogger.Handler.formatter=java.util.logging.SimpleFormatter jmxlogger.Handler.objectName=jmxlogger.util.logging:type=JmxLogHandler jmxlogger.Handler.server=platform # Console log handler java.util.logging.ConsoleHandler.level = INFO java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter Java Logging ExampleOnce you have your handler configured, you simply use the logging API as you normally do. Usage of JmxLogger will be transparent to the developer. You simply send your log event to your logging framework. The framework then delegates propagation of your log event as JMX notifications using the JmxLogger API. import java.util.logging.Level; import java.util.logging.LogManager; import java.util.logging.Logger; public class SomeClassA { private static final Logger logger = Logger.getLogger(SomeClassA.class.getName()); public static void main(String[] args) { logger.log(Level.INFO, "I am happy!"); logger.log(Level.WARNING, "I am concerned..."); logger.log(Level.SEVERE, "I am in trouble, something went wrong."); logger.log(Level.FINE, "I am up, I am down, I am all around!"); } }For detail on how to use Java Util Logging API, see Java Logging Overview. Log4J AppenderSimilarly to Java Logging, JmxLogger supports the Log4J framework for logging. If you are a user of the Log4J framework, you should already be familiar with the configuration steps for the Log4J logger. Below is a sample log4j.xml configuration file. It shows how the JmxLogger Appender is configured for logging. The appender supports several attributes which can be left blank. The class defaults to sensible defaults if an attribute is missing. Log4J ExampleOnce you have JmxLogger configured (for Java Logging or Log4J), you are ready to use it. Usage of JmxLogger will be transparent to the developer. You simply send your log event to your logging framework. The framework then delegates propagation of your log event as JMX notifications using the JmxLogger API. import org.apache.log4j.Level; import org.apache.log4j.Logger; public class SomeClassB { private static Logger logger = Logger.getLogger(SomeClassB.class); public static void main (String[] args) { logger.log(Level.INFO, "I am happy!"); logger.log(Level.WARN, "I am concerned..."); logger.log(Level.ERROR, "I am in trouble, something went wrong."); logger.log(Level.DEBUG, "I am up, I am down, I am all around!"); } }JmxLogger LogsWhen you log your event using either Java Logging or Log4J (as show above in the example sections), your log events will get routed to the Handler or Appender defined in your configuration files. In both examples, we have a console and JmxLogger defined. Therefore, all logged events will be show up in the standard console. Logged events will also be emitted as JMX notifications. Using JConsole, you can see these events as they are logged in your application. That's it! You have seen how JmxLogger can effortlessly integrate JMX and the two standard logging API's available (Java Logging and Log4J). [Less]

The goal is to create a simple class that will broadcast logging info in a generic fashion so that any logger could use it. Ideally an OpenLogger application could act as a shell to your preferred ... [More] logging tool. All it would take would be for someone to create a plugin for that logger. [Less]

Just a place to host my google apps