Free log files safe to delete software for linux

Log Mine is a tool that produces reports on usage patterns on your Web site.
Web server log files are not just hit counters. They contain valuable information about the usage patterns of your website. Unforunately many web log analysis tools lay emphasis on telling you how many hits your site had or how many pages were seen and how many bytes were transferred.
A more usefull statistic would be which percentage of users came to your site went to a product information page, and which percentage of those users hit the checkout button, and which percentage actually completed their order. The trouble is the very nature of the web makes it nearly impossible to get accurate figures for such statistics.
However over periods of time, the errors present average out and it is possible to get a good indication of these ratios by properly mining the log file. That brings us back to square one, how do we get this information with traditional log analysers?
Traditional log analysers will produce weekly, monthly or daily charts for the usage of your site, but rarely do they allow you to create such charts for individual pages or referrrs - something very usefull if you run advertising campaigns on other sites.
Enter Log Mine. This new web log analyser / Mining tool will allow you to create just about any kind of report from the contents of your log file. Log Mine is not concerned about speed and it will be very greedy when it comes to taking up space on your hard disk/database but it will let you change your reporting without having to process gigabytes of log files each time.
Enhancements:
- Importing of Web server log files into the database was simplified.
- Multiple log files can now be processed at once.
- A bug in the monthly report was fixed.

Log::Dispatch::Atom is a Perl module to log to an atom feed.

SYNOPSIS

use Log::Dispatch::Atom;

my $log = Log::Dispatch::Atom->new(
name => foo,
min_level => debug,
file => file.atom
);
$log->log_message( level => error, message => A problem happened );
$log->log_message( level => debug, message => Got Here );

This class implements logging backed by an Atom feed so that you can subscribe to the errors produced by your application.

You should not use this object directly, but should manage it via a Log::Dispatch object.

IMPLEMENTATION NOTES

In order to safely write to the log file, the entire file must be locked each time that an entry is logged. This probably makes it unsuitable for high volume log files.
The log file is opened and closed on each call to log_message().

METHODS

new()

Takes a hash of arguments. Returns a new Log::Dispatch::Atom object. The following parameters are used:

name [mandatory]

The name of the logging object.

min_level [mandatory]

The minimum logging level this object will accept. See Log::Dispatch for more information.

max_level [optional]

The maximum logging level this object will accept. See Log::Dispatch for more information. The default is the highest possible level (ie: no maximum).

file [mandatory]

Specifies the location of the file to read/write the feed from.

feed_id [optional]

Specifies the identity of the feed itself. Normally, this should be set to the published URI of the feed.
If not specified, it will be omitted, which is in violation of the Atom specification. For more information, see http://www.atomenabled.org/developers/syndication/#requiredFeedElements.

feed_title [optional]

The title of the feed. This should probably be set to the name of your application.

If not specified, it will be omitted, which is in violation of the Atom specification. For more information, see http://www.atomenabled.org/developers/syndication/#requiredFeedElements.
XXX This should probably just use the name parameter. What do you think? Let me know.

feed_author [optional]

The author details of a feed. This is specified as a hash reference, which must contain one or more of the three keys name, email and uri.

In order to create a valid Atom feed, you must either supply an author in every single entry (log message), or ensure that the feed itself has an author. The latter is probably the easier solution, so I recommend this parameter be supplied.

NB: The feed_* parameters will only be used when a new feed is being created. If you are creating a new object for an existing feed, they will be ignored.

log_message()

Takes a hash of arguments. Has no return value. The following parameters are used.

message [mandatory]

The actual log message.

level [mandatory]

The level of the message. See Log::Dispatch for a full list.

id [optional]

Each entry requires an id in order for the feed as a whole to be a valid Atom document. Its used by readers of Atom documents to determine whether or not an entry has been seen previously.

If not specified, this will default to an URL comprising the current time plus the pid plus the hostname plus a monotonically increasing integer. eg: tag:fred.example.com,2005-12-07:1133946771/20827/2. This should be good enough for a uniqueness test.

author [optional]

You can specify author details for an individual entry if desired. The author parameter is expected to be a hash reference, which must contain one or more of the keys name, email or uri.

Log::Log4perl::AutoCategorize - extended Log::Log4perl logging.

ABSTRACT

Log::Log4perl::AutoCategorize extends Log::Log4perls (l4p) easy mode, adding 2 main features;
1. extended, automatic, transparent categorization capabilities
a. logging category Logger, # shorthand class-name alias
# you can initialize in use statement
# 1st way gives separation of code from config
# 2nd way is good for demonstration and early development
initfile => $filename,
initstr => q{
# see Log4perl docs to understand these directives
log4perl.rootLogger=DEBUG, A1
# log4perl.appender.A1=Log::Dispatch::Screen
log4perl.appender.A1 = Log::Dispatch::File
log4perl.appender.A1.filename = ./mylog
log4perl.appender.A1.mode = write
log4perl.appender.A1.layout = PatternLayout
log4perl.appender.A1.layout.ConversionPattern=%d %c %m%n
# create TEST-COVERAGE log
log4perl.appender.COVERAGE = Log::Dispatch::File
log4perl.appender.COVERAGE.mode = write
log4perl.appender.COVERAGE.layout = org.apache.log4j.PatternLayout
log4perl.appender.COVERAGE.layout.ConversionPattern = (%d{HH:mm:ss.SSS}) %c: %m%n
# save timestamped versions, 1 per process
log4perl.appender.COVERAGE.filename = sub {"./test-coverage.txt.". scalar localtime}

# now, add the value: send the stuff written at END to it
log4perl.logger.Log.Log4perl.Autocategorize.END = INFO, COVERAGE
},
);

foreach (1..500) {
Logger->warn($_);
foo();
A->bar();
A::bar();
}

sub foo {
foreach (1..20) {
Logger->warn($_);
}
}

package A;

sub bar {
my @d;
foreach (reverse 1..10) {
push @d, $_;
Logger->warn("t-minus:", $_,@d);
}
}

loggerfs is the virtual file system that allows you to store logs in a database. I just released the first version of it (checkout the News) and will now be focusing on supporting more logging formats. If you dont yet know what loggerfs is, then heres a simple explanation for when you need it:

- Are you running cron scripts periodically to parse log files and put them in a database?
- Do you need to store log files remotely because you have limited space?
- Would you like a more efficient solution than simply polling the log files and waiting for new data?

If you answer yes to any of the above questions, please take a look at loggerfs. It will allow you to create virtual files to which you can then direct syslog/ apache/ squid/ etc. to log to. For example, instead of having syslog store authentication information in /var/log/auth.log, you could create a virtual file in /var/loggerfs/auth.log and then tell syslog to log to that file. Now instead of storing the information in the auth.log file, the data is actually sent to a database server that you defined in the logs.xml file. Every time new information is sent to the file, it is immediately sent to the database server, which means that:

- It doesnt poll for information, it listens, which makes it a lot more efficient.
- It automatically creates the tables in the database and makes sure that all the information can be stored.
- Youll be able to easily sort/ analyze the log files once theyre in the database.

I encourage you to checkout the CVS on the sourceforge project page, and let me know if you have any questions/ problems/ suggestions.

Log::Dispatch::File::Rolling is a Perl object for logging to date/time/pid stamped files.

SYNOPSIS

use Log::Dispatch::File::Rolling;

my $file = Log::Dispatch::File::Rolling->new(
name => file1,
min_level => info,
filename => Somefile%d{yyyyMMdd}.log,
mode => append );

$file->log( level => emerg,
message => "Ive fallen and I cant get upn" );

ABSTRACT

This module provides an object for logging to files under the Log::Dispatch::* system.

This module subclasses Log::Dispatch::File for logging to date/time stamped files. See Log::Dispatch::File for instructions on usage. This module differs only on the following three points:

fork()-safe

This module will close and re-open the logfile after a fork.

multitasking-safe

This module uses flock() to lock the file while writing to it.

stamped filenames

This module supports a special tag in the filename that will expand to the current date/time/pid.

It is the same tag Log::Log4perl::Layout::PatternLayout uses, see Log::Log4perl::Layout::PatternLayout, chapter "Fine-tune the date". In short: Include a "%d{...}" in the filename where "..." is a format string according to the SimpleDateFormat in the Java World (http://java.sun.com/j2se/1.3/docs/api/java/text/SimpleDateFormat.html). See also Log::Log4perl::DateFormat for information about further restrictions.
In addition to the format provided by Log::Log4perl::DateFormat this module also supports $ for inserting the PID. Repeat the character to define how many character wide the field should be. This should not be needed regularly as this module also supports logfile sharing between processes, but if youve got a high load on your logfile or a system that doesnt support flock()...

LogServ is a module for NeoStats IRC Services that logs channel actions and messages to a log file for processing by channel log file parsers such as pisg, Onis, or MircStats.
LogServ can enable an IRC network to host the channel information Web pages commonly found for popular channels detailing information such as the number of people that have joined an IRC channel, or who spoke the most words.
Enhancements:
- Many internal code cleanups and bugfixes were done.
- This release is compatible with the latest alpha release of NeoStats 3.0.

File::Xcopy can copy files after comparing them.
SYNOPSIS
use File::Xcopy;
my $fx = new File::Xcopy;
$fx->from_dir("/from/dir");
$fx->to_dir("/to/dir");
$fx->fn_pat((.pl|.txt)$); # files with pl & txt extensions
$fx->param(s,1); # search recursively to sub dirs
$fx->param(verbose,1); # search recursively to sub dirs
$fx->param(log_file,/my/log/file.log);
my ($sr, $rr) = $fx->get_stat;
$fx->xcopy; # or
$fx->execute(copy);
# the same with short name
$fx->xcp("from_dir", "to_dir", "file_name_pattern");
The File::Xcopy module provides two basic functions, xcopy and xmove, which are useful for coping and/or moving a file or files in a directory from one place to another. It mimics some of behaviours of xcopy in DOS but with more functions and options.
The differences between xcopy and copy are:
- xcopy searches files based on file name pattern if the pattern is specified.
- xcopy compares the timestamp and size of a file before it copies.
- xcopy takes different actions if you tell it to.
The Constructor new(%arg)
Without any input, i.e., new(), the constructor generates an empty object with default values for its parameters.
If any argument is provided, the constructor expects them in the name and value pairs, i.e., in a hash array.