';
my $pgbadger_ico =
'data:image/x-icon;base64,
AAABAAEAIyMQAAEABAA8BAAAFgAAACgAAAAjAAAARgAAAAEABAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAgAAGRsZACgqKQA2OTcASEpJAFpdWwBoa2kAeHt5AImMigCeoZ8AsLOxAMTHxQDR1NIA
5enmAPv+/AAAAAAA///////////////////////wAAD///////////H///////////AAAP//////
//9Fq7Yv////////8AAA////////8V7u7qD////////wAAD///////8B7qWN5AL///////AAAP//
///y8Avrc3rtMCH/////8AAA/////xABvbAAAJ6kAA/////wAAD////wAG5tQAAADp6RAP////AA
AP//MQBd7C2lRESOWe5xAD//8AAA//8APO7iC+7e7u4A3uxwBf/wAAD/9Aju7iAAvu7u0QAN7ukA
7/AAAP/wCe7kAAAF7ugAAAHO6xD/8AAA//AK7CAAAAHO1AAAABnrEP/wAAD/8ArAAAAAAc7kAAAA
AIwQ//AAAP/wCjAAAAAC3uQAAAAAHBCf8AAA//AIEBVnIATu5gAXZhAFEP/wAAD/8AIAqxdwBu7p
AFoX0QIQ//AAAP/wAAPsBCAL7u4QBwfmAAD/8AAA//AAA8owAC7u7lAAKbYAAJ/wAAD/8AAAAAAA
fu7uwAAAAAAA//AAAP/wAAAAAADu7u7jAAAAAAD/8AAA//AAAAAABe7u7uoAAAAAAP/wAAD/8AAA
AAAL7u7u7QAAAAAAn/AAAP/wAAAAAB3u7u7uYAAAAAD/8AAA//MAAAAATu7u7u6QAAAAAP/wAAD/
/wAAAAAM7u7u7TAAAAAD//AAAP//IQAAAAKu7u7UAAAAAB//8AAA////IAAAAAju7BAAAAAP///w
AAD////2AAA1je7ulUAAA/////AAAP/////xEAnO7u7pIAH/////8AAA//////9CABju6iACP///
///wAAD////////wAAggAP////////AAAP////////8wAAA/////////8AAA///////////w////
///////wAAD///////////////////////AAAP/////gAAAA//+//+AAAAD//Af/4AAAAP/4A//g
AAAA//AA/+AAAAD/oAA/4AAAAP8AAB/gAAAA/gAAD+AAAADwAAAB4AAAAPAAAADgAAAA4AAAAGAA
AADgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAAYAAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAA
AOAAAABgAAAA4AAAAOAAAADgAAAA4AAAAOAAAADgAAAA4AAAAGAAAADgAAAA4AAAAOAAAADgAAAA
8AAAAOAAAADwAAAB4AAAAPwAAAfgAAAA/gAAD+AAAAD/gAA/4AAAAP/AAH/gAAAA//gD/+AAAAD/
/Af/4AAAAP//v//gAAAA/////+AAAAA
';
my %CLASS_ERROR_CODE = (
'00' => 'Successful Completion',
'01' => 'Warning',
'02' => 'No Data (this is also a warning class per the SQL standard)',
'03' => 'SQL Statement Not Yet Complete',
'08' => 'Connection Exception',
'09' => 'Triggered Action Exception',
'0A' => 'Feature Not Supported',
'0B' => 'Invalid Transaction Initiation',
'0F' => 'Locator Exception',
'0L' => 'Invalid Grantor',
'0P' => 'Invalid Role Specification',
'0Z' => 'Diagnostics Exception',
'20' => 'Case Not Found',
'21' => 'Cardinality Violation',
'22' => 'Data Exception',
'23' => 'Integrity Constraint Violation',
'24' => 'Invalid Cursor State',
'25' => 'Invalid Transaction State',
'26' => 'Invalid SQL Statement Name',
'27' => 'Triggered Data Change Violation',
'28' => 'Invalid Authorization Specification',
'2B' => 'Dependent Privilege Descriptors Still Exist',
'2D' => 'Invalid Transaction Termination',
'2F' => 'SQL Routine Exception',
'34' => 'Invalid Cursor Name',
'38' => 'External Routine Exception',
'39' => 'External Routine Invocation Exception',
'3B' => 'Savepoint Exception',
'3D' => 'Invalid Catalog Name',
'3F' => 'Invalid Schema Name',
'40' => 'Transaction Rollback',
'42' => 'Syntax Error or Access Rule Violation',
'44' => 'WITH CHECK OPTION Violation',
'53' => 'Insufficient Resources',
'54' => 'Program Limit Exceeded',
'55' => 'Object Not In Prerequisite State',
'57' => 'Operator Intervention',
'58' => 'System Error (errors external to PostgreSQL itself)',
'72' => 'Snapshot Failure',
'F0' => 'Configuration File Error',
'HV' => 'Foreign Data Wrapper Error (SQL/MED)',
'P0' => 'PL/pgSQL Error',
'XX' => 'Internal Error',
);
####
# method used to fork as many child as wanted
##
sub spawn
{
my $coderef = shift;
unless (@_ == 0 && $coderef && ref($coderef) eq 'CODE') {
print "usage: spawn CODEREF";
exit 0;
}
my $pid;
if (!defined($pid = fork)) {
print STDERR "Error: cannot fork: $!\n";
return;
} elsif ($pid) {
$RUNNING_PIDS{$pid} = $pid;
return; # the parent
}
# the child -- go spawn
$< = $>;
$( = $); # suid progs only
exit &$coderef();
}
# Command line options
my $journalctl_cmd = '';
my $zcat_cmd = 'gunzip -c';
my $zcat = $zcat_cmd;
my $bzcat = 'bunzip2 -c';
my $ucat = 'unzip -p';
my $xzcat = 'xzcat';
my $gzip_uncompress_size = "gunzip -l %f | grep -E '^\\s*[0-9]+' | awk '{print \$2}'";
my $zip_uncompress_size = "unzip -l %f | awk '{if (NR==4) print \$1}'";
my $xz_uncompress_size = "xz --robot -l %f | grep totals | awk '{print \$5}'";
my $format = '';
my $outfile = '';
my $outdir = '';
my $incremental = '';
my $extra_files = 0;
my $help = '';
my $ver = '';
my @dbname = ();
my @dbuser = ();
my @dbclient = ();
my @dbappname = ();
my @exclude_user = ();
my @exclude_appname = ();
my @exclude_line = ();
my $ident = '';
my $top = 0;
my $sample = 3;
my $extension = '';
my $maxlength = 0;
my $graph = 1;
my $nograph = 0;
my $debug = 0;
my $nohighlight = 0;
my $noprettify = 0;
my $from = '';
my $to = '';
my $quiet = 0;
my $progress = 1;
my $error_only = 0;
my @exclude_query = ();
my @exclude_time = ();
my $exclude_file = '';
my @include_query = ();
my $include_file = '';
my $disable_error = 0;
my $disable_hourly = 0;
my $disable_type = 0;
my $disable_query = 0;
my $disable_session = 0;
my $disable_connection = 0;
my $disable_lock = 0;
my $disable_temporary = 0;
my $disable_checkpoint = 0;
my $disable_autovacuum = 0;
my $avg_minutes = 5;
my $histo_avg_minutes = 60;
my $last_parsed = '';
my $report_title = '';
my $log_line_prefix = '';
my $compiled_prefix = '';
my $project_url = 'http://dalibo.github.com/pgbadger/';
my $t_min = 0;
my $t_max = 0;
my $remove_comment = 0;
my $select_only = 0;
my $tsung_queries = 0;
my $queue_size = 0;
my $job_per_file = 0;
my $charset = 'utf-8';
my $csv_sep_char = ',';
my %current_sessions = ();
my %pgb_current_sessions = ();
my $incr_date = '';
my $last_incr_date = '';
my $anonymize = 0;
my $noclean = 0;
my $retention = 0;
my $bar_graph = 0;
my $dns_resolv = 0;
my $nomultiline = 0;
my $noreport = 0;
my $log_duration = 0;
my $logfile_list = '';
my $enable_checksum = 0;
my $timezone = 0;
my $pgbouncer_only = 0;
my $rebuild = 0;
my $week_start_monday = 0;
my $use_sessionid_as_pid = 0;
my $dump_normalized_only = 0;
my $NUMPROGRESS = 10000;
my @DIMENSIONS = (800, 300);
my $RESRC_URL = '';
my $img_format = 'png';
my @log_files = ();
my %prefix_vars = ();
my $remote_host = '';
my $ssh_command = '';
my $ssh_bin = 'ssh';
my $ssh_identity = '';
my $ssh_user = '';
my $ssh_timeout = 10;
my $ssh_options = "-o ConnectTimeout=$ssh_timeout -o PreferredAuthentications=hostbased,publickey";
# OBSOLETE, to be removed
# List of regex that match fatal error message that do not
# generate disconnection line in log. This is to prevent
# sessions in the sessions charts to increase continually.
# See issue #176 on github
my @session_closed_msg = (
qr/^(database|role) "[^"]+" does not exist$/,
qr/^no pg_hba.conf entry for/,
);
my $sql_prettified;
# Do not display data in pie where percentage is lower than this value
# to avoid label overlapping.
my $pie_percentage_limit = 2;
# Get the decimal separator
my $n = 5 / 2;
my $num_sep = ',';
$num_sep = ' ' if ($n =~ /,/);
# Inform the parent that it should stop iterate on parsing other files
sub stop_parsing
{
&logmsg('DEBUG', "Received interrupt signal");
$interrupt = 1;
}
# With multiprocess we need to wait for all children
sub wait_child
{
my $sig = shift;
$interrupt = 2;
print STDERR "Received terminating signal ($sig).\n";
if ($^O !~ /MSWin32|dos/i) {
1 while wait != -1;
$SIG{INT} = \&wait_child;
$SIG{TERM} = \&wait_child;
foreach my $f (@tempfiles) {
unlink("$f->[1]") if (-e "$f->[1]");
}
}
if ($last_parsed && -e "$tmp_last_parsed") {
unlink("$tmp_last_parsed");
}
if ($last_parsed && -e "$last_parsed.tmp") {
unlink("$last_parsed.tmp");
}
if (-e "$PID_DIR/pgbadger.pid") {
unlink("$PID_DIR/pgbadger.pid");
}
_exit(0);
}
$SIG{INT} = \&wait_child;
$SIG{TERM} = \&wait_child;
$SIG{USR2} = \&stop_parsing;
$| = 1;
# get the command line parameters
my $result = GetOptions(
"a|average=i" => \$avg_minutes,
"A|histo-average=i" => \$histo_avg_minutes,
"b|begin=s" => \$from,
"B|bar-graph!" => \$bar_graph,
"c|dbclient=s" => \@dbclient,
"C|nocomment!" => \$remove_comment,
"d|dbname=s" => \@dbname,
"D|dns-resolv!" => \$dns_resolv,
"e|end=s" => \$to,
"f|format=s" => \$format,
"G|nograph!" => \$nograph,
"h|help!" => \$help,
"i|ident=s" => \$ident,
"I|incremental!" => \$incremental,
"j|jobs=i" => \$queue_size,
"J|job_per_file=i" => \$job_per_file,
"l|last-parsed=s" => \$last_parsed,
"L|logfile-list=s" => \$logfile_list,
"m|maxlength=i" => \$maxlength,
"M|no-multiline!" => \$nomultiline,
"N|appname=s" => \@dbappname,
"n|nohighlight!" => \$nohighlight,
"o|outfile=s" => \$outfile,
"O|outdir=s" => \$outdir,
"p|prefix=s" => \$log_line_prefix,
"P|no-prettify!" => \$noprettify,
"q|quiet!" => \$quiet,
"r|remote-host=s" => \$remote_host,
'R|retention=i' => \$retention,
"s|sample=i" => \$sample,
"S|select-only!" => \$select_only,
"t|top=i" => \$top,
"T|title=s" => \$report_title,
"u|dbuser=s" => \@dbuser,
"U|exclude-user=s" => \@exclude_user,
"v|verbose!" => \$debug,
"V|version!" => \$ver,
"w|watch-mode!" => \$error_only,
"x|extension=s" => \$extension,
"X|extra-files!" => \$extra_files,
"z|zcat=s" => \$zcat,
"Z|timezone=s" => \$timezone,
"pie-limit=i" => \$pie_percentage_limit,
"image-format=s" => \$img_format,
"exclude-query=s" => \@exclude_query,
"exclude-file=s" => \$exclude_file,
"exclude-appname=s" => \@exclude_appname,
"include-query=s" => \@include_query,
"exclude-line=s" => \@exclude_line,
"include-file=s" => \$include_file,
"disable-error!" => \$disable_error,
"disable-hourly!" => \$disable_hourly,
"disable-type!" => \$disable_type,
"disable-query!" => \$disable_query,
"disable-session!" => \$disable_session,
"disable-connection!" => \$disable_connection,
"disable-lock!" => \$disable_lock,
"disable-temporary!" => \$disable_temporary,
"disable-checkpoint!" => \$disable_checkpoint,
"disable-autovacuum!" => \$disable_autovacuum,
"charset=s" => \$charset,
"csv-separator=s" => \$csv_sep_char,
"exclude-time=s" => \@exclude_time,
'ssh-command=s' => \$ssh_command,
'ssh-program=s' => \$ssh_bin,
'ssh-identity=s' => \$ssh_identity,
'ssh-option=s' => \$ssh_options,
'ssh-user=s' => \$ssh_user,
'ssh-timeout=i' => \$ssh_timeout,
'anonymize!' => \$anonymize,
'noclean!' => \$noclean,
'noreport!' => \$noreport,
'log-duration!' => \$log_duration,
'enable-checksum!' => \$enable_checksum,
'journalctl=s' => \$journalctl_cmd,
'pid-dir=s' => \$PID_DIR,
'rebuild!' => \$rebuild,
'pgbouncer-only!' => \$pgbouncer_only,
'start-monday!' => \$week_start_monday,
'normalized-only!' => \$dump_normalized_only,
);
die "FATAL: use pgbadger --help\n" if (not $result);
$report_title = &escape_html($report_title) if $report_title;
if ($ver) {
print "pgBadger version $VERSION\n";
exit 0;
}
&usage() if ($help);
# Try to load Digest::MD5 when asked
if ($enable_checksum) {
if (eval {require Digest::MD5;1} ne 1) {
die("Can not load Perl module Digest::MD5.\n");
} else {
Digest::MD5->import('md5_hex');
}
}
# Check if an other process is already running
if (-e "$PID_DIR/pgbadger.pid") {
my $is_running = 2;
if ($^O !~ /MSWin32|dos/i) {
eval { $is_running = `ps auwx | grep pgbadger | grep -v grep | wc -l`; chomp($is_running); };
}
if (!$@ && ($is_running <= 1)) {
unlink("$PID_DIR/pgbadger.pid");
} else {
print "FATAL: an other process is already started or remove the file, see $PID_DIR/pgbadger.pid\n";
exit 3;
}
}
# Create pid file
unless(open(OUT, ">$PID_DIR/pgbadger.pid")) {
print "FATAL: can't create pid file $PID_DIR/pgbadger.pid, $!\n";
exit 3;
}
print OUT $$;
close(OUT);
# Rewrite some command line arguments as lists
&compute_arg_list();
# If pgBadger must parse remote files set the ssh command
if ($remote_host) {
# If no user defined ssh command
if (!$ssh_command) {
$ssh_command = $ssh_bin || 'ssh';
$ssh_command .= " -i $ssh_identity" if ($ssh_identity);
$ssh_command .= " $ssh_options" if ($ssh_options);
if ($ssh_user) {
$ssh_command .= " $ssh_user\@$remote_host";
} else {
$ssh_command .= " $remote_host";
}
}
}
# Add journalctl command to the file list if not already found
if ($journalctl_cmd) {
if (!grep(/^\Q$journalctl_cmd\E$/, @ARGV)) {
$journalctl_cmd .= " --output='short-iso'";
push(@ARGV, $journalctl_cmd);
}
}
# Log files to be parsed are passed as command line arguments
my $empty_files = 1;
if ($#ARGV >= 0) {
foreach my $file (@ARGV) {
if ( $journalctl_cmd && ($file =~ m/\Q$journalctl_cmd\E/) ) {
push(@log_files, $file);
$empty_files = 0;
} elsif ($file ne '-') {
if (!$remote_host) {
localdie("FATAL: logfile \"$file\" must exist!\n") if (not -f $file);
if (-z $file) {
print "WARNING: file $file is empty\n" if (!$quiet);
next;
}
push(@log_files, $file);
$empty_files = 0;
} else {
# Get files from remote host
&logmsg('DEBUG', "Looking for remote filename using command: $ssh_command \"ls $file\"");
my @rfiles = `$ssh_command "ls $file"`;
foreach my $f (@rfiles) {
push(@log_files, $f);
}
$empty_files = 0;
}
} else {
if ($logfile_list) {
localdie("FATAL: stdin input - can not be used with logfile list (-L).\n");
}
push(@log_files, $file);
$empty_files = 0;
}
}
}
# Read list of log file to parse from a file
if ($logfile_list) {
if (!-e $logfile_list) {
localdie("FATAL: logfile list $logfile_list must exist!\n");
}
if (not open(IN, $logfile_list)) {
localdie("FATAL: can not read logfile list $logfile_list, $!.\n");
}
my @files = Year $y
| ", &get_calendar($y, $m), " | \n"; print $fh "
};
# get year directories
unless(opendir(DIR, "$outdir")) {
localdie("Error: can't opendir $outdir: $!");
}
my @dyears = grep { !/^\./ && /^\d{4}$/ } readdir(DIR);
closedir DIR;
foreach my $y (sort { $b <=> $a } @dyears) {
print $fh qq{
};
}
print $fh qq{
};
$fh->close;
}
sub cleanup_directory
{
my ($dir, $remove_dir) = @_;
unless(opendir(DIR, "$dir")) {
localdie("Error: can't opendir $dir: $!");
}
my @todel = grep { !/^\./ } readdir(DIR);
closedir DIR;
map { unlink("$dir/$_"); } @todel;
rmdir("$dir") if ($remove_dir);
}
sub write_resources
{
# Write resource file to report directory or return resources in and array of lines
my $rscfh;
my @contents = ();
my $endfile = '';
my $file = '';
my $major_version = $VERSION;
$major_version =~ s/\..*//;
while (my $l = ) {
if ($l =~ /^WRFILE: ([^\s]+)/) {
$file = $1;
if (!$extra_files) {
if ($#contents > 0) {
push(@contents, $endfile);
}
if ($file =~ /\.css$/i) {
push(@contents, "";
} elsif ($file =~ /\.js$/i) {
push(@contents, "";
}
next;
}
$rscfh->close() if (defined $rscfh);
if ($file =~ /\.css$/i) {
push(@contents, "\n");
} elsif ($file =~ /\.js$/i) {
push(@contents, "\n");
}
if (!-e "$outdir/$major_version") {
mkdir("$outdir/$major_version");
}
if (!-e "$outdir/$major_version/$file") {
$rscfh = new IO::File ">$outdir/$major_version/$file";
localdie("FATAL: can't write file $outdir/$major_version/$file\n") if (not defined $rscfh);
}
next;
}
if (!$extra_files) {
push(@contents, $l);
} else {
$rscfh->print($l) if (defined $rscfh);
}
}
$rscfh->close() if (defined $rscfh);
# Return __DATA__ content if --extra-files is not used
# or HTML links to resources files
if (!$extra_files) {
push(@contents, $endfile);
}
return @contents;
}
sub sort_by_week
{
my $curr = shift;
my $next = shift;
$a =~ /week\-(\d+)/;
$curr = $1;
$b =~ /week\-(\d+)/;
$next = $1;
return $next <=> $curr;
}
sub init_stats_vars
{
# Empty where statistics are stored
%overall_stat = ();
%pgb_overall_stat = ();
%overall_checkpoint = ();
@top_slowest = ();
@top_tempfile_info = ();
@top_cancelled_info = ();
@top_locked_info = ();
%normalyzed_info = ();
%error_info = ();
%pgb_error_info = ();
%pgb_pool_info = ();
%logs_type = ();
%errors_code = ();
%per_minute_info = ();
%pgb_per_minute_info = ();
%lock_info = ();
%tempfile_info = ();
%cancelled_info = ();
%connection_info = ();
%pgb_connection_info = ();
%database_info = ();
%application_info = ();
%session_info = ();
%pgb_session_info = ();
%conn_received = ();
%checkpoint_info = ();
%autovacuum_info = ();
%autoanalyze_info = ();
@graph_values = ();
%cur_info = ();
$nlines = 0;
%tsung_session = ();
}
####
# Main function called per each parser process
####
sub multiprocess_progressbar
{
my $totalsize = shift;
&logmsg('DEBUG', "Starting progressbar writer process");
$0 = 'pgbadger logger';
# Terminate the process when we haven't read the complete file but must exit
local $SIG{USR1} = sub {
print STDERR "\n";
exit 1;
};
my $timeout = 3;
my $cursize = 0;
my $nqueries = 0;
my $nerrors = 0;
my $last = 0;
$pipe->reader();
while (my $r = <$pipe>) {
chomp($r);
my @infos = split(/\s+/, $r);
last if ($infos[0] eq 'QUIT');
$cursize += $infos[0];
$nqueries += $infos[1];
$nerrors += $infos[2];
$cursize = $totalsize if ($cursize > $totalsize);
print STDERR &progress_bar($cursize, $totalsize, 25, '=', $nqueries, $nerrors);
}
print STDERR "\n";
exit 0;
}
sub update_progress_bar
{
my ($tmpoutfile, $nlines, $stop_offset, $totalsize, $cursize, $old_queries_count, $old_errors_count) = @_;
if (!$tmpoutfile) {
if ($progress && (($nlines % $NUMPROGRESS) == 0)) {
if ($totalsize) {
print STDERR &progress_bar($$cursize, $stop_offset || $totalsize, 25, '=');
} else {
print STDERR ".";
}
}
} else {
if ($progress && (($nlines % $NUMPROGRESS) == 0)) {
$pipe->print("$$cursize " . ($overall_stat{'queries_number'} - $$old_queries_count) . " " . (($overall_stat{'errors_number'}+$pgb_overall_stat{'errors_number'}) - $$old_errors_count) . "\n");
$$old_queries_count = $overall_stat{'queries_number'};
$$old_errors_count = $overall_stat{'errors_number'}+$pgb_overall_stat{'errors_number'};
$$cursize = 0;
}
}
}
####
# Main function called per each parser process
####
sub process_file
{
my ($logfile, $fmt, $tmpoutfile, $start_offset, $stop_offset, $chunk_pos) = @_;
my $old_queries_count = 0;
my $old_errors_count = 0;
my $getout = 0;
$start_offset ||= 0;
$0 = 'pgbadger parser';
&init_stats_vars() if ($tmpoutfile);
if (!$remote_host) {
&logmsg('DEBUG', "Starting to parse log file: $logfile");
} else {
&logmsg('DEBUG', "Starting to parse remote log file: $remote_host:$logfile");
}
local $SIG{INT} = sub { print STDERR "Received SIGINT abort parsing...\n"; unlink("$PID_DIR/pgbadger.pid"); $terminate = 1; };
local $SIG{TERM} = sub { print STDERR "Received SIGTERM abort parsing...\n"; unlink("$PID_DIR/pgbadger.pid"); $terminate = 1; };
my $curdate = localtime(time);
$pipe->writer() if (defined $pipe);
# Syslog does not have year information, so take care of year overlapping
my ($gsec, $gmin, $ghour, $gmday, $gmon, $gyear, $gwday, $gyday, $gisdst) = localtime(time);
$gyear += 1900;
my $CURRENT_DATE = $gyear . sprintf("%02d", $gmon + 1) . sprintf("%02d", $gmday);
my $cursize = 0;
# Get file handle and size of the file
my ($lfile, $totalsize) = &get_log_file($logfile);
# Reset the start position if file is smaller that the current start offset
if ($start_offset > $totalsize) {
&logmsg('DEBUG', "Starting offset $start_offset is greater than total size $totalsize for file $logfile");
&logmsg('DEBUG', "Reverting start offset $start_offset to 0 for file $logfile, stoppping offset is " . ($stop_offset || $totalsize));
$start_offset = 0 ;
}
# Check if the first date in the log are after the last date saved
if (($fmt ne 'binary') && ($fmt ne 'csv')) {
if ($start_offset && !$chunk_pos) {
my ($retcode, $msg) = check_file_changed($logfile, $fmt, ($fmt eq 'pgbouncer') ? $pgb_saved_last_line{datetime} : $saved_last_line{datetime}, $start_offset, 1);
if ($retcode) {
&logmsg('DEBUG', "This file should be parsed from the beginning: $logfile, $msg");
&logmsg('DEBUG', "Reverting start offset $start_offset to 0 for file $logfile, stoppping offset is " . ($stop_offset || $totalsize));
$start_offset = 0;
} else {
&logmsg('DEBUG', "This might not be parsed: $logfile, $msg");
}
$cursize = $start_offset;
}
} else {
$start_offset = 0;
$stop_offset = 0;
}
if ($stop_offset > 0) {
$totalsize = $stop_offset - $start_offset;
}
my $current_offset = $start_offset || 0;
# Forward the progress bar to the starting point in MP mode
#$cursize = $start_offset if ($chunk_pos == 0);
if (!$remote_host) {
&logmsg('DEBUG', "Starting reading file $logfile...");
} else {
&logmsg('DEBUG', "Starting reading file $remote_host:$logfile...");
}
# Parse pgbouncer logfile
if ($fmt eq 'pgbouncer') {
my $time_pattern = qr/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/;
my $cur_pid = '';
my @matches = ();
my $has_exclusion = 0;
if ($#exclude_line >= 0) {
$has_exclusion = 1;
}
&logmsg('DEBUG', "Start parsing at offset $start_offset of file $logfile to " . ($stop_offset || $totalsize));
if ($start_offset) {
# Move to the starting offset position in file
$lfile->seek($start_offset, 0);
}
while (my $line = <$lfile>) {
# We received a signal
last if ($terminate);
# Get current size/offset in the log file
$cursize += length($line);
$current_offset += length($line);
# Replace CR/LF by LF
$line =~ s/\r//;
# Start to exclude from parsing any desired lines
if ($has_exclusion >= 0) {
# Log line matches the excluded regex
map { next if ($line =~ /$_/is); } @exclude_line;
}
chomp($line);
$nlines++;
next if (!$line);
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
%prefix_vars = ();
@matches = ($line =~ $pgbouncer_log_parse1);
if ($#matches >= 0) {
for (my $i = 0 ; $i <= $#pgb_prefix_parse1 ; $i++) {
$prefix_vars{$pgb_prefix_parse1[$i]} = $matches[$i];
}
# Get time detailed information
($prefix_vars{'t_year'}, $prefix_vars{'t_month'}, $prefix_vars{'t_day'}, $prefix_vars{'t_hour'},
$prefix_vars{'t_min'}, $prefix_vars{'t_sec'}) = ($prefix_vars{'t_timestamp'} =~ $time_pattern);
# Skip unwanted lines
my $res = &skip_unwanted_line();
next if ($res == 1);
if ($res == -1) {
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
$getout = 2;
last;
}
# Jump to the last line parsed if required
next if (!&check_incremental_position($fmt, $prefix_vars{'t_timestamp'}, $line));
# Extract other information from the line
@matches = ($line =~ $pgbouncer_log_parse2);
if ($#matches >= 0) {
for (my $i = 0 ; $i <= $#pgb_prefix_parse2 ; $i++) {
$prefix_vars{$pgb_prefix_parse2[$i]} = $matches[$i];
}
$prefix_vars{'t_client'} = _gethostbyaddr($prefix_vars{'t_client'}) if ($dns_resolv && $prefix_vars{'t_client'});
} else {
# pgBouncer Statistics appears each minutes in the log
if ($prefix_vars{'t_query'} =~ /Stats: (\d+) req\/s, in (\d+) b\/s, out (\d+) b\/s,query (\d+) us/) {
$prefix_vars{'t_loglevel'} = 'STATS';
$prefix_vars{'t_req/s'} = $1;
$prefix_vars{'t_inbytes/s'} = $2;
$prefix_vars{'t_outbytes/s'} = $3;
$prefix_vars{'t_avgduration'} = $4;
}
}
# Store the current timestamp of the log line
&store_current_timestamp($prefix_vars{'t_timestamp'});
# Check if the log line should be excluded from the report
if (&validate_log_line($prefix_vars{'t_pid'})) {
$prefix_vars{'t_host'} = 'stderr'; # this unused variable is used to store format information when log format is not syslog
# Process the log line
&parse_pgbouncer($fmt);
}
} else {
# unknown format
&logmsg('DEBUG', "Unknown pgbouncer line format: $line");
}
last if (($stop_offset > 0) && ($current_offset >= $stop_offset));
}
if ($last_parsed) {
$pgb_last_line{current_pos} = $current_offset;
}
# Parse PostgreSQL log file with CSV format
} elsif ($fmt eq 'csv') {
require Text::CSV_XS;
my $csv = Text::CSV_XS->new(
{
binary => 1,
eol => $/,
sep_char => $csv_sep_char,
allow_loose_quotes => 1,
}
);
# Parse csvlog lines
CSVLOOP: while (!$csv->eof()) {
while (my $row = $csv->getline($lfile)) {
$row =~ s/\r//;
# We received a signal
last CSVLOOP if ($terminate);
# Number of columns in csvlog (22 before 9.0 and 23 from 9.0 to current)
next if ( ($#{$row} != 22) && ($#{$row} != 21) );
# Set progress statistics
$cursize += length(join(',', @$row));
$nlines++;
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
next if ( ($row->[11] !~ $parse_regex) || ($row->[11] eq 'LOCATION'));
# Extract the date
if ($row->[0] =~ m/^(\d+)-(\d+)-(\d+)\s+(\d+):(\d+):(\d+)\.(\d+)/) {
# Remove newline characters from queries
map { s/[\r\n]+/ /gs; } @$row;
my $milli = $7 || 0;
($prefix_vars{'t_year'}, $prefix_vars{'t_month'}, $prefix_vars{'t_day'}, $prefix_vars{'t_hour'}, $prefix_vars{'t_min'}, $prefix_vars{'t_sec'}) = ($1, $2, $3, $4, $5, $6);
$prefix_vars{'t_timestamp'} = "$1-$2-$3 $4:$5:$6";
# Skip unwanted lines
my $res = &skip_unwanted_line();
next if ($res == 1);
if ($res == -1) {
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
$getout = 2;
last CSVLOOP;
}
# Jump to the last line parsed if required
next if (!&check_incremental_position($fmt, $prefix_vars{'t_timestamp'}, join(',', @$row)));
# Store the current timestamp of the log line
&store_current_timestamp($prefix_vars{'t_timestamp'});
# Set query parameters as global variables
$prefix_vars{'t_dbuser'} = $row->[1] || '';
$prefix_vars{'t_dbname'} = $row->[2] || '';
$prefix_vars{'t_appname'} = $row->[22] || '';
$prefix_vars{'t_client'} = $row->[4] || '';
$prefix_vars{'t_client'} =~ s/:.*//;
$prefix_vars{'t_client'} = _gethostbyaddr($prefix_vars{'t_client'}) if ($dns_resolv);
$prefix_vars{'t_host'} = 'csv'; # this unused variable is used to store format information when log format is not syslog
$prefix_vars{'t_pid'} = $row->[3];
$prefix_vars{'t_session_line'} = $row->[5];
$prefix_vars{'t_session_line'} =~ s/\..*//;
$prefix_vars{'t_loglevel'} = $row->[11];
$prefix_vars{'t_query'} = $row->[13];
# Set ERROR additional information
$prefix_vars{'t_detail'} = $row->[14];
$prefix_vars{'t_hint'} = $row->[15];
$prefix_vars{'t_context'} = $row->[18];
$prefix_vars{'t_statement'} = $row->[19];
# Check if the log line should be excluded from the report
if (&validate_log_line($prefix_vars{'t_pid'})) {
# Parse the query now
&parse_query($fmt);
# The information can be saved immediately with csvlog
&store_queries($prefix_vars{'t_pid'});
delete $cur_info{$prefix_vars{'t_pid'}};
}
}
}
if (!$csv->eof()) {
warn "WARNING: cannot use CSV on $logfile, " . $csv->error_diag() . " at line " . ($nlines+1), "\n";
print STDERR "DETAIL: " . $csv->error_input(), "\n" if ($csv->error_input());
print STDERR "reset CSV parser\n";
$csv->SetDiag(0);
}
}
}
elsif ($fmt eq 'binary') {
&load_stats($lfile);
}
else { # Format is not CSV.
my $time_pattern = qr/(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/;
my $cur_pid = '';
my @matches = ();
my $goon = 0;
my $has_exclusion = 0;
if ($#exclude_line >= 0) {
$has_exclusion = 1;
}
&logmsg('DEBUG', "Start parsing at offset $start_offset of file $logfile to " . ($stop_offset || $totalsize));
if ($start_offset) {
# Move to the starting offset position in file
$lfile->seek($start_offset, 0);
}
while (my $line = <$lfile>) {
# We received a signal
last if ($terminate);
# Get current size/offset in the log file
$cursize += length($line);
$current_offset += length($line);
# Replace CR/LF by LF
$line =~ s/\r//;
# Start to exclude from parsing any desired lines
if ($has_exclusion >= 0) {
# Log line matches the excluded regex
map { next if ($line =~ /$_/is); } @exclude_line;
}
chomp($line);
$nlines++;
next if (!$line);
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
%prefix_vars = ();
# Parse syslog lines
if ($fmt =~ /syslog/) {
@matches = ($line =~ $compiled_prefix);
if ($#matches >= 0) {
for (my $i = 0 ; $i <= $#prefix_params ; $i++) {
$prefix_vars{$prefix_params[$i]} = $matches[$i];
}
# skip non postgresql lines
next if ($prefix_vars{'t_ident'} ne $ident);
# Skip location information
next if ($prefix_vars{'t_loglevel'} eq 'LOCATION');
# Standard syslog format does not have year information, months are
# three letters and days are not always with 2 digits.
if ($prefix_vars{'t_month'} !~ /\d/) {
$prefix_vars{'t_year'} = $gyear;
$prefix_vars{'t_day'} = sprintf("%02d", $prefix_vars{'t_day'});
$prefix_vars{'t_month'} = $month_abbr{$prefix_vars{'t_month'}};
# Take care of year overlapping
if ("$prefix_vars{'t_year'}$prefix_vars{'t_month'}$prefix_vars{'t_day'}" > $CURRENT_DATE) {
$prefix_vars{'t_year'} = substr($CURRENT_DATE, 0, 4) - 1;
}
}
$prefix_vars{'t_timestamp'} =
"$prefix_vars{'t_year'}-$prefix_vars{'t_month'}-$prefix_vars{'t_day'} $prefix_vars{'t_hour'}:$prefix_vars{'t_min'}:$prefix_vars{'t_sec'}";
if ($prefix_vars{'t_hostport'} && !$prefix_vars{'t_client'}) {
$prefix_vars{'t_client'} = $prefix_vars{'t_hostport'};
# Remove the port part
$prefix_vars{'t_client'} =~ s/\(.*//;
}
# Skip unwanted lines
my $res = &skip_unwanted_line();
next if ($res == 1);
if ($res == -1) {
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
$getout = 2;
last;
}
# Jump to the last line parsed if required
next if (!&check_incremental_position($fmt, $prefix_vars{'t_timestamp'}, $line));
$goon = 1;
$prefix_vars{'t_client'} = _gethostbyaddr($prefix_vars{'t_client'}) if ($dns_resolv);
# Store the current timestamp of the log line
&store_current_timestamp($prefix_vars{'t_timestamp'});
# Extract information from log line prefix
if (!$log_line_prefix) {
&parse_log_prefix($prefix_vars{'t_logprefix'});
}
# Check if the log line should be excluded from the report
if (&validate_log_line($prefix_vars{'t_pid'})) {
# The information can be saved when we are switching to a new main message
if ($cur_pid && ($prefix_vars{'t_loglevel'} =~ /^(LOG|ERROR|FATAL|PANIC|WARNING)$/)) {
&store_queries($cur_pid);
delete $cur_info{$cur_pid} if (!$log_duration || (($cur_info{$cur_pid}{duration} ne '') && ($cur_info{$cur_pid}{query} ne '')));
}
# Process the log line
&parse_query($fmt);
}
$cur_pid = $prefix_vars{'t_pid'};
} elsif ($goon && ($line =~ $other_syslog_line)) {
$cur_pid = $8;
my $t_query = $10;
$t_query =~ s/#011/\t/g;
next if ($t_query eq "\t");
# Some log line may be written by applications
next if ($t_query =~ /\bLOG: /);
# Parse orphan lines to append inforamtion to the right place
&parse_orphan_line($cur_pid, $t_query);
# Collect orphaned lines of multiline queries
} elsif ($cur_pid) {
# Some log line may be written by applications
next if ($line =~ /\bLOG: /);
# Parse orphan lines to append inforamtion to the right place
&parse_orphan_line($cur_pid, $line);
} else {
&logmsg('DEBUG', "Unknown syslog line format: $line");
}
} elsif ($fmt eq 'stderr') {
@matches = ($line =~ $compiled_prefix);
if ($#matches >= 0) {
# Store auto explain plan when switching to an other log entry
foreach my $p (keys %cur_plan_info) {
if (exists $cur_plan_info{$p}{plan}) {
# Extract the query part from the plan
my $key = 'query';
my @plan = split("\n", $cur_plan_info{$p}{plan});
foreach my $l (@plan) {
$key = 'plan' if ($l =~ /\(cost=\d+.*rows=\d+/);
$cur_info{$p}{$key} .= "$l\n";
}
$cur_info{$p}{query} =~ s/^\s*Query Text:\s+//s;
delete $cur_plan_info{$p};
&store_queries($p);
delete $cur_info{$p};
}
}
for (my $i = 0 ; $i <= $#prefix_params ; $i++) {
$prefix_vars{$prefix_params[$i]} = $matches[$i];
}
$prefix_vars{'t_pid'} = $prefix_vars{'t_session_id'} if ($use_sessionid_as_pid);
# Skip location information
next if ($prefix_vars{'t_loglevel'} eq 'LOCATION');
if (!$prefix_vars{'t_timestamp'} && $prefix_vars{'t_mtimestamp'}) {
$prefix_vars{'t_timestamp'} = $prefix_vars{'t_mtimestamp'};
} elsif (!$prefix_vars{'t_timestamp'} && $prefix_vars{'t_session_timestamp'}) {
$prefix_vars{'t_timestamp'} = $prefix_vars{'t_session_timestamp'};
} elsif (!$prefix_vars{'t_timestamp'} && $prefix_vars{'t_epoch'}) {
$prefix_vars{'t_timestamp'} = strftime("%Y-%m-%d %H:%M:%S", CORE::localtime($prefix_vars{'t_epoch'}));
if ($prefix_vars{'t_epoch'} =~ /^\d{10}(\.\d{3})$/) {
$prefix_vars{'t_timestamp'} .= $1;
}
} elsif ($prefix_vars{'t_timestamp'} =~ /^\d{10}(\.\d{3})$/) {
my $ms = $1;
$prefix_vars{'t_epoch'} = $prefix_vars{'t_timestamp'};
$prefix_vars{'t_timestamp'} = strftime("%Y-%m-%d %H:%M:%S", CORE::localtime($prefix_vars{'t_timestamp'}));
$prefix_vars{'t_timestamp'} .= $ms;
}
($prefix_vars{'t_year'}, $prefix_vars{'t_month'}, $prefix_vars{'t_day'}, $prefix_vars{'t_hour'},
$prefix_vars{'t_min'}, $prefix_vars{'t_sec'}) = ($prefix_vars{'t_timestamp'} =~ $time_pattern);
if ($prefix_vars{'t_hostport'} && !$prefix_vars{'t_client'}) {
$prefix_vars{'t_client'} = $prefix_vars{'t_hostport'};
# Remove the port part
$prefix_vars{'t_client'} =~ s/\(.*//;
}
# Skip unwanted lines
my $res = &skip_unwanted_line();
next if ($res == 1);
if ($res == -1) {
&update_progress_bar($tmpoutfile, $nlines, $stop_offset, $totalsize, \$cursize, \$old_queries_count, \$old_errors_count);
$getout = 2;
last;
}
# Jump to the last line parsed if required
next if (!&check_incremental_position($fmt, $prefix_vars{'t_timestamp'}, $line));
$prefix_vars{'t_client'} = _gethostbyaddr($prefix_vars{'t_client'}) if ($dns_resolv);
# Store the current timestamp of the log line
&store_current_timestamp($prefix_vars{'t_timestamp'});
# Extract information from log line prefix
if (!$log_line_prefix) {
&parse_log_prefix($prefix_vars{'t_logprefix'});
}
# Check if the log line should be excluded from the report
if (&validate_log_line($prefix_vars{'t_pid'})) {
# this unused variable is used to store format information
# when log format is not syslog
$prefix_vars{'t_host'} = 'stderr';
# The information can be saved when we are switching to a new main message
if ($cur_pid && $prefix_vars{'t_loglevel'} =~ /^(LOG|ERROR|FATAL|PANIC|WARNING)$/) {
&store_queries($cur_pid);
delete $cur_info{$cur_pid} if (!$log_duration || (($cur_info{$cur_pid}{duration} ne '') && ($cur_info{$cur_pid}{query} ne '')));
}
# Process the log line
&parse_query($fmt);
}
$cur_pid = $prefix_vars{'t_pid'};
# Collect additional query information
} elsif ($cur_pid) {
# Some log line may be written by applications
next if ($line =~ /\bLOG: /);
# Parse orphan lines to append inforamtion to the right place
&parse_orphan_line($cur_pid, $line);
} else {
# unknown format
&logmsg('DEBUG', "Unknown line format: $line");
}
}
last if (($stop_offset > 0) && ($current_offset >= $stop_offset));
}
if ($last_parsed) {
$last_line{current_pos} = $current_offset;
}
}
close $lfile;
# Inform the parent that it should stop parsing other files
if ($terminate) {
kill('USR2', $parent_pid);
return $terminate;
}
# Get stats from all pending temporary storage
foreach my $pid (sort {$cur_info{$a}{date} <=> $cur_info{$b}{date}} keys %cur_info) {
# Stores last query information
&store_queries($pid, 1);
}
# Stores last temporary files and lock information
foreach my $pid (keys %cur_temp_info) {
&store_temporary_and_lock_infos($pid);
}
# Stores last cancelled queries information
foreach my $pid (keys %cur_cancel_info) {
&store_temporary_and_lock_infos($pid);
}
# Stores last temporary files and lock information
foreach my $pid (keys %cur_lock_info) {
&store_temporary_and_lock_infos($pid);
}
if ($extension eq 'tsung') {
foreach my $pid (sort {$a <=> $b} keys %tsung_session) {
&store_tsung_session($pid);
}
}
if ($progress && ($getout != 1)) {
if (!$tmpoutfile) {
if ($totalsize) {
print STDERR &progress_bar($cursize, $stop_offset || $totalsize, 25, '=',$overall_stat{'queries_number'},($overall_stat{'errors_number'}+$pgb_overall_stat{'errors_number'}), $logfile);
print STDERR "\n";
}
} else {
$pipe->print("$cursize " . ($overall_stat{'queries_number'} - $old_queries_count) . " " . (($overall_stat{'errors_number'}+$pgb_overall_stat{'errors_number'}) - $old_errors_count) . "\n");
}
}
%cur_info = ();
# In incremental mode data are saved to disk per day
if ($incremental && ($last_line{datetime} || (($fmt eq 'pgbouncer') && $pgb_last_line{datetime}))) {
$incr_date = ($fmt eq 'pgbouncer') ? $pgb_last_line{datetime} : $last_line{datetime};
$incr_date =~ s/\s.*$//;
# set path and create subdirectories
if ($incr_date =~ /^(\d+)-(\d+)-(\d+)/) {
mkdir("$outdir/$1") if (!-d "$outdir/$1");
mkdir("$outdir/$1/$2") if (!-d "$outdir/$1/$2");
mkdir("$outdir/$1/$2/$3") if (!-d "$outdir/$1/$2/$3");
} else {
&logmsg('ERROR', "invalid incremental date: $incr_date, can not create subdirectories.");
}
my $bpath = $incr_date;
$bpath =~ s/\-/\//g;
# Mark the directory as needing index update
if (open(OUT, ">>$last_parsed.tmp")) {
flock(OUT, 2) || return $getout;
print OUT "$incr_date\n";
close(OUT);
} else {
&logmsg('ERROR', "can't save last parsed line into $last_parsed.tmp, $!");
}
# Save binary data
my $filenum = $$;
$filenum++ while (-e "$outdir/$bpath/$incr_date-$filenum.bin");
my $fhb = new IO::File ">$outdir/$bpath/$incr_date-$filenum.bin";
if (not defined $fhb) {
localdie("FATAL: can't write to $outdir/$bpath/$incr_date-$filenum.bin, $!\n");
}
&dump_as_binary($fhb);
$fhb->close;
&init_stats_vars();
} elsif ($tmpoutfile) {
&dump_as_binary($tmpoutfile);
$tmpoutfile->close();
}
# Save last line into temporary file
if ($last_parsed && (scalar keys %last_line || scalar keys %pgb_last_line)) {
if (open(OUT, ">>$tmp_last_parsed")) {
flock(OUT, 2) || return $getout;
if ($fmt eq 'pgbouncer') {
$pgb_last_line{current_pos} ||= 0;
&logmsg('DEBUG', "Saving pgbouncer last parsed line into $tmp_last_parsed ($pgb_last_line{datetime}\t$pgb_last_line{current_pos})");
print OUT "pgbouncer\t$pgb_last_line{datetime}\t$pgb_last_line{current_pos}\t$pgb_last_line{orig}\n";
} else {
$last_line{current_pos} ||= 0;
&logmsg('DEBUG', "Saving last parsed line into $tmp_last_parsed ($last_line{datetime}\t$last_line{current_pos})");
print OUT "$last_line{datetime}\t$last_line{current_pos}\t$last_line{orig}\n";
}
close(OUT);
} else {
&logmsg('ERROR', "can't save last parsed line into $tmp_last_parsed, $!");
}
}
# Inform the parent that it should stop parsing other files
if ($getout) {
kill('USR2', $parent_pid);
}
return $getout;
}
sub parse_orphan_line
{
my ($cur_pid, $line) = @_;
# Store vacuum related information
if ($cur_info{$cur_pid}{vacuum} && ($line =~ /^\t?(pages|tuples|buffer usage|avg read rate|system usage):/)) {
if ($line =~ /^\t?(pages|tuples): (\d+) removed, (\d+) remain/) {
$autovacuum_info{tables}{$cur_info{$cur_pid}{vacuum}}{$1}{removed} += $2;
}
if ($line =~ m#^\t?system usage: CPU .* sec elapsed (.*) sec#) {
if ($1 > $autovacuum_info{peak}{system_usage}{elapsed}) {
$autovacuum_info{peak}{system_usage}{elapsed} = $1;
$autovacuum_info{peak}{system_usage}{table} = $cur_info{$cur_pid}{vacuum};
$autovacuum_info{peak}{system_usage}{date} =
"$cur_info{$cur_pid}{year}-$cur_info{$cur_pid}{month}-$cur_info{$cur_pid}{day} " .
"$cur_info{$cur_pid}{hour}:$cur_info{$cur_pid}{min}:$cur_info{$cur_pid}{sec}";
}
}
# stores bind parameters if parameter syntax is detected
} elsif ( $cur_info{$cur_pid}{parameters} && (($line =~ /[,\s]*\$(\d+)\s=\s/) || ($line =~ /^'[^']*'$/)) ) {
$cur_info{$cur_pid}{parameters} .= " $line" if (!$error_only);
} elsif (exists $cur_plan_info{$cur_pid}) {
$cur_plan_info{$cur_pid}{plan} .= "\n" . $line;
# If we have previously stored a temporary file query, append to that query
} elsif (exists $cur_temp_info{$cur_pid}{size}) {
$cur_temp_info{$cur_pid}{query} .= "\n" . $line;
# If we have previously stored a query that generates locks, append to that query
} elsif (exists $cur_lock_info{$cur_pid}{query}) {
$cur_lock_info{$cur_pid}{query} .= "\n" . $line;
# If we have previously stored a cancelled query, append to that query
} elsif (exists $cur_cancel_info{$cur_pid}{query}) {
$cur_cancel_info{$cur_pid}{query} .= "\n" . $line;
# Otherwise append the orphan line to the corresponding part of the query
} else {
# Append to the error statement if one is defined
if (exists $cur_info{$cur_pid}{statement}) {
$cur_info{$cur_pid}{statement} .= "\n" . $line if (!$nomultiline);
# Append to the error context if one is defined
} elsif (exists $cur_info{$cur_pid}{context}) {
$cur_info{$cur_pid}{context} .= "\n" . $line;
# Append to the query detail if one is defined
} elsif (exists $cur_info{$cur_pid}{detail}) {
$cur_info{$cur_pid}{detail} .= "\n" . $line;
# After all append to the query if one is defined
} elsif (exists $cur_info{$cur_pid}{query}) {
$cur_info{$cur_pid}{query} .= "\n" . $line if (!$nomultiline && !$error_only);
}
}
}
# Store the current timestamp of the log line
sub store_current_timestamp
{
my $t_timestamp = shift;
$prefix_vars{'t_date'} = $t_timestamp;
$prefix_vars{'t_date'} =~ s/\D+//g;
if (!$overall_stat{'first_log_ts'} || ($overall_stat{'first_log_ts'} gt $t_timestamp)) {
$overall_stat{'first_log_ts'} = $t_timestamp;
}
if (!$overall_stat{'last_log_ts'} || ($overall_stat{'last_log_ts'} lt $t_timestamp)) {
$overall_stat{'last_log_ts'} = $t_timestamp;
}
}
# Method used to check if the log file is produced by pgbouncer
sub detect_pgbouncer_log
{
my ($file, $saved_date, $look_at_beginning) = @_;
my ($lfile, $totalsize, $iscompressed) = &get_log_file($file);
# Compressed files do not allow seeking
if ($iscompressed) {
$look_at_beginning = 1;
}
my ($gsec, $gmin, $ghour, $gmday, $gmon, $gyear, $gwday, $gyday, $gisdst) = localtime(time);
$gyear += 1900;
my $CURRENT_DATE = $gyear . sprintf("%02d", $gmon + 1) . sprintf("%02d", $gmday);
%prefix_vars = ();
my $startoffset = 0;
# If seeking is not explicitely disabled
if (!$look_at_beginning) {
# do not seek if filesize is smaller than the seek position
if ($saved_last_line{current_pos} < $totalsize) {
$lfile->seek($saved_last_line{current_pos} || 0, 0);
$startoffset = $saved_last_line{current_pos} || 0;
}
}
my $more_lines = 0;
my $ispgbouncerlog = 0;
while (my $line = <$lfile>) {
$more_lines++;
$line =~ s/\r//;
my @matches = ($line =~ $pgbouncer_log_format);
if ($#matches >= 0) {
$ispgbouncerlog++;
for (my $i = 0 ; $i <= $#pgb_prefix_params ; $i++) {
$prefix_vars{$pgb_prefix_params[$i]} = $matches[$i];
}
} else {
@matches = ($line =~ $pgbouncer_log_parse1);
if (($#matches >= 0) && ($matches[-1] =~ /^Stats:/) ) {
$ispgbouncerlog++;
for (my $i = 0 ; $i <= $#pgb_prefix_parse1 ; $i++) {
$prefix_vars{$pgb_prefix_params[$i]} = $matches[$i];
}
}
}
next if (!$prefix_vars{'t_timestamp'});
if ($iscompressed) {
close($lfile);
return ($ispgbouncerlog, 0, "log file is compressed start at offset 0");
# This file has already been parsed
} elsif ($saved_date gt $prefix_vars{'t_timestamp'}) {
close($lfile);
return ($ispgbouncerlog, 0, "timestamp $prefix_vars{'t_timestamp'} read at offset $startoffset is lower than saved timestamp: $saved_date");
} else {
last;
}
}
close($lfile);
if (!$more_lines) {
close($lfile);
return ($ispgbouncerlog, 0, "there no new lines in this file");
}
return ($ispgbouncerlog, 1, "reach the end of detect_pgbouncer_log() with start date: $saved_date and file size: $totalsize") ;
}
# Method used to check if the file stores logs after the last incremental position or not
# This position should have been saved in the incremental file and read in the $last_parsed at
# start up. Here we just verify that the first date in file is before the last incremental date.
sub check_file_changed
{
my ($file, $fmt, $saved_date, $saved_pos, $look_at_beginning) = @_;
my ($lfile, $totalsize, $iscompressed) = &get_log_file($file);
# Compressed files do not allow seeking
if ($iscompressed) {
close($lfile);
return (1, "log file is compressed");
}
my ($gsec, $gmin, $ghour, $gmday, $gmon, $gyear, $gwday, $gyday, $gisdst) = localtime(time);
$gyear += 1900;
my $CURRENT_DATE = $gyear . sprintf("%02d", $gmon + 1) . sprintf("%02d", $gmday);
%prefix_vars = ();
my $startoffset = 0;
# If seeking is not explicitely disabled
if (!$look_at_beginning) {
# do not seek if filesize is smaller than the seek position
if ($saved_pos < $totalsize) {
$lfile->seek($saved_pos || 0, 0);
$startoffset = $saved_pos || 0;
}
}
my $more_lines = 0;
while (my $line = <$lfile>) {
$more_lines++;
$line =~ s/\r//;
if ($fmt =~ /syslog/) {
my @matches = ($line =~ $compiled_prefix);
if ($#matches >= 0) {
for (my $i = 0 ; $i <= $#prefix_params ; $i++) {
$prefix_vars{$prefix_params[$i]} = $matches[$i];
}
# Standard syslog format does not have year information, months are
# three letters and days are not always with 2 digits.
if ($prefix_vars{'t_month'} !~ /\d/) {
$prefix_vars{'t_year'} = $gyear;
$prefix_vars{'t_day'} = sprintf("%02d", $prefix_vars{'t_day'});
$prefix_vars{'t_month'} = $month_abbr{$prefix_vars{'t_month'}};
# Take care of year overlapping
if ("$prefix_vars{'t_year'}$prefix_vars{'t_month'}$prefix_vars{'t_day'}" > $CURRENT_DATE) {
$prefix_vars{'t_year'} = substr($CURRENT_DATE, 0, 4) - 1;
}
}
$prefix_vars{'t_timestamp'} =
"$prefix_vars{'t_year'}-$prefix_vars{'t_month'}-$prefix_vars{'t_day'} $prefix_vars{'t_hour'}:$prefix_vars{'t_min'}:$prefix_vars{'t_sec'}";
}
} elsif ($fmt eq 'stderr') {
my @matches = ($line =~ $compiled_prefix);
if ($#matches >= 0) {
for (my $i = 0 ; $i <= $#prefix_params ; $i++) {
$prefix_vars{$prefix_params[$i]} = $matches[$i];
}
if (!$prefix_vars{'t_timestamp'} && $prefix_vars{'t_mtimestamp'}) {
$prefix_vars{'t_timestamp'} = $prefix_vars{'t_mtimestamp'};
} elsif (!$prefix_vars{'t_timestamp'} && $prefix_vars{'t_session_timestamp'}) {
$prefix_vars{'t_timestamp'} = $prefix_vars{'t_session_timestamp'};
} elsif (!$prefix_vars{'t_timestamp'} && $prefix_vars{'t_epoch'}) {
$prefix_vars{'t_timestamp'} = strftime("%Y-%m-%d %H:%M:%S", CORE::localtime($prefix_vars{'t_epoch'}));
if ($prefix_vars{'t_epoch'} =~ /^\d{10}(\.\d{3})$/) {
$prefix_vars{'t_timestamp'} .= $1;
}
}
}
} elsif ($fmt eq 'pgbouncer') {
my @matches = ($line =~ $pgbouncer_log_parse1);
if ($#matches >= 0) {
for (my $i = 0 ; $i <= $#pgb_prefix_parse1 ; $i++) {
$prefix_vars{$pgb_prefix_parse1[$i]} = $matches[$i];
}
}
}
# Unwanted line
next if (!$prefix_vars{'t_timestamp'});
# This file has already been parsed
if ($saved_date gt $prefix_vars{'t_timestamp'}) {
close($lfile);
return (0, "timestamp $prefix_vars{'t_timestamp'} read at offset $startoffset is lower than saved timestamp: $saved_date");
} else {
last;
}
}
close($lfile);
if (!$more_lines) {
close($lfile);
return (0, "there no new lines in this file");
}
return (1, "reach the end of check_file_changed() with start date: $saved_date and file size: $totalsize") ;
}
# Method used to check if we have already reached the last parsing position in incremental mode
# This position should have been saved in the incremental file and read in the $last_parsed at
# start up.
sub check_incremental_position
{
my ($fmt, $cur_date, $line) = @_;
if ($last_parsed && ($fmt ne 'pgbouncer')) {
if ($saved_last_line{datetime}) {
if ($cur_date lt $saved_last_line{datetime}) {
return 0;
} elsif (!$last_line{datetime} && ($cur_date eq $saved_last_line{datetime})) {
return 0 if ($line ne $saved_last_line{orig});
}
}
$last_line{datetime} = $cur_date;
$last_line{orig} = $line;
} elsif ($last_parsed) {
if ($pgb_saved_last_line{datetime}) {
if ($cur_date lt $pgb_saved_last_line{datetime}) {
return 0;
} elsif (!$pgb_last_line{datetime} && ($cur_date eq $pgb_saved_last_line{datetime})) {
return 0 if ($line ne $pgb_saved_last_line{orig});
}
}
$pgb_last_line{datetime} = $cur_date;
$pgb_last_line{orig} = $line;
}
# In incremental mode data are saved to disk per day
if ($incremental) {
$cur_date =~ s/\s.*$//;
# Check if the current day has changed, if so save data
$incr_date = $cur_date if (!$incr_date);
if ($cur_date gt $incr_date) {
# Get stats from all pending temporary storage
foreach my $pid (sort {$cur_info{$a}{date} <=> $cur_info{$b}{date}} keys %cur_info) {
# Stores last queries information
&store_queries($pid, 1);
}
# Stores last temporary files and lock information
foreach my $pid (keys %cur_temp_info) {
&store_temporary_and_lock_infos($pid);
}
# Stores last cancelled queries information
foreach my $pid (keys %cur_cancel_info) {
&store_temporary_and_lock_infos($pid);
}
# Stores last temporary files and lock information
foreach my $pid (keys %cur_lock_info) {
&store_temporary_and_lock_infos($pid);
}
# Stores tsung sessions
if ($extension eq 'tsung') {
foreach my $pid (sort {$a <=> $b} keys %tsung_session) {
&store_tsung_session($pid);
}
}
# set path and create subdirectories
if ($incr_date =~ /^(\d+)-(\d+)-(\d+)/) {
mkdir("$outdir/$1") if (!-d "$outdir/$1");
mkdir("$outdir/$1/$2") if (!-d "$outdir/$1/$2");
mkdir("$outdir/$1/$2/$3") if (!-d "$outdir/$1/$2/$3");
} else {
&logmsg('ERROR', "invalid incremental date: $incr_date, can not create subdirectories.");
}
my $bpath = $incr_date;
$bpath =~ s/\-/\//g;
# Mark this directory as needing a reindex
if (open(OUT, ">>$last_parsed.tmp")) {
flock(OUT, 2) || return 1;
print OUT "$incr_date\n";
close(OUT);
} else {
&logmsg('ERROR', "can't save last parsed line into $last_parsed.tmp, $!");
}
# Save binary data
my $filenum = $$;
$filenum++ while (-e "$outdir/$bpath/$incr_date-$filenum.bin");
my $fhb = new IO::File ">$outdir/$bpath/$incr_date-$filenum.bin";
if (not defined $fhb) {
localdie("FATAL: can't write to $outdir/$bpath/$incr_date-$filenum.bin, $!\n");
}
&dump_as_binary($fhb);
$fhb->close;
$incr_date = $cur_date;
&init_stats_vars();
}
}
return 1;
}
# Display message following the log level
sub logmsg
{
my ($level, $str) = @_;
return if ($quiet && ($level ne 'FATAL'));
return if (!$debug && ($level eq 'DEBUG'));
if ($level =~ /(\d+)/) {
print STDERR "\t" x $1;
}
print STDERR "$level: $str\n";
}
# Remove quote from alias for normalisation
sub remove_alias
{
my $str = shift();
$str =~ s/'//gs;
return $str;
}
# Normalize SQL queries by removing parameters
sub normalize_query
{
my $orig_query = shift;
return if (!$orig_query);
# Remove comments
$orig_query =~ s/\/\*(.*?)\*\///gs;
# Set the entire query lowercase
$orig_query = lc($orig_query);
# Remove extra space, new line and tab characters by a single space
$orig_query =~ s/\s+/ /gs;
# Removed start of transaction
if ($orig_query !~ /^\s*begin\s*;\s*$/) {
$orig_query =~ s/^\s*begin\s*;\s*//gs
}
# Normalise alias with quote
$orig_query =~ s/AS\s+"([^"]+)"/'AS "' . remove_alias($1) . '"'/eigs;
# Remove string content
$orig_query =~ s/\\'//gs;
$orig_query =~ s/'[^']*'/''/gs;
$orig_query =~ s/''('')+/''/gs;
# Remove NULL parameters
$orig_query =~ s/=\s*NULL/=''/gs;
# Remove numbers
$orig_query =~ s/([^a-z0-9_\$\-])-?\d+/${1}0/gs;
# Remove hexadecimal numbers
$orig_query =~ s/([^a-z_\$-])0x[0-9a-f]{1,10}/${1}0x/gs;
# Remove bind parameters
$orig_query =~ s/\$\d+/\?/gs;
# Remove IN values
$orig_query =~ s/\bin\s*\([\'0x,\s\?]*\)/in (...)/gs;
# Remove curor names in CURSOR and IN clauses
$orig_query =~ s/\b(declare|in)\s+"[^"]+"/$1 "..."/gs;
return $orig_query;
}
sub generate_anonymized_string
{
my ($original, $cache, $before) = @_;
# Prevent dates from being anonymized
return $original if $original =~ m{\A\d\d\d\d[/:-]\d\d[/:-]\d\d\z};
return $original if $original =~ m{\A\d\d[/:-]\d\d[/:-]\d\d\d\d\z};
# Prevent dates format like DD/MM/YYYY HH24:MI:SS from being anonymized
return $original if $original =~ m{\A(?:FM|FX|TM)?(?:HH|HH12|HH24|MI|SS|MS|US|SSSS|AM|A\.M\.|PM|P\.M\.|am|a\.m\.|pm|p\.m\.|Y,YYY|YYYY|YYY|YY|Y|IYYY|IYY|IY|I|BC|B\.C\.|AD|A\.D\.|bc|b\.c\.|ad|a\.d\.|MONTH|Month|month|MON|Mon|mon|MM|DAY|Day|day|DY|Dy|dy|DDD|DD|D|W|WW|IW|CC|J|Q|RM|rm|TZ|tz|[\s\/\-:])+(?:TH|th|SP)?$};
# Prevent interval from being anonymized
return $original if $before =~ /interval/i;
# Range of characters to use in anonymized strings
my @chars = ('A'..'Z', 0..9, 'a'..'z', '-', '_', '.');
unless ($cache->{$original}) {
# Actual anonymized version generation
$cache->{$original} = join('', map { $chars[rand @chars] } 1..10 );
}
return $cache->{$original};
}
# Anonymize litteral in SQL queries by replacing parameters with fake values
sub anonymize_query
{
my $orig_query = shift;
return if (!$orig_query);
# Variable to hold anonymized versions, so we can provide the same value
# for the same input, within single query.
my $anonymization_cache = {};
# Remove comments
$orig_query =~ s/\/\*(.*?)\*\///gs;
# Clean query
$orig_query =~ s/\\'//g;
$orig_query =~ s/('')+//g;
# Anonymize each values
$orig_query =~ s/([^\s]+[\s\(]*)'([^']*)'/"$1'".generate_anonymized_string($2, $anonymization_cache, $1)."'"/eg;
return $orig_query;
}
# Format numbers with comma for better reading
sub comma_numbers
{
return 0 if ($#_ < 0);
return 0 if (!$_[0]);
my $text = reverse $_[0];
$text =~ s/(\d\d\d)(?=\d)(?!\d*\.)/$1$num_sep/g;
return scalar reverse $text;
}
# Format numbers with comma for better reading
sub pretty_print_size
{
my $val = shift;
return 0 if (!$val);
if ($val >= 1125899906842624) {
$val = ($val / 1125899906842624);
$val = sprintf("%0.2f", $val) . " PiB";
} elsif ($val >= 1099511627776) {
$val = ($val / 1099511627776);
$val = sprintf("%0.2f", $val) . " TiB";
} elsif ($val >= 1073741824) {
$val = ($val / 1073741824);
$val = sprintf("%0.2f", $val) . " GiB";
} elsif ($val >= 1048576) {
$val = ($val / 1048576);
$val = sprintf("%0.2f", $val) . " MiB";
} elsif ($val >= 1024) {
$val = ($val / 1024);
$val = sprintf("%0.2f", $val) . " KiB";
} else {
$val = $val . " B";
}
return $val;
}
# Format duration
sub convert_time
{
my $time = shift;
return '0ms' if (!$time);
my $days = int($time / 86400000);
$time -= ($days * 86400000);
my $hours = int($time / 3600000);
$time -= ($hours * 3600000);
my $minutes = int($time / 60000);
$time -= ($minutes * 60000);
my $seconds = int($time / 1000);
$time -= ($seconds * 1000);
my $milliseconds = sprintf("%.3d", $time);
$days = $days < 1 ? '' : $days . 'd';
$hours = $hours < 1 ? '' : $hours . 'h';
$minutes = $minutes < 1 ? '' : $minutes . 'm';
$seconds = $seconds < 1 ? '' : $seconds . 's';
$milliseconds = $milliseconds < 1 ? '' : $milliseconds . 'ms';
if ($days || $hours || $minutes) {
$milliseconds = '';
} elsif ($seconds) {
$milliseconds =~ s/\.\d+//;
}
$milliseconds =~ s/^[0]+// if ($milliseconds !~ /\./);
$time = $days . $hours . $minutes . $seconds . $milliseconds;
$time = '0ms' if ($time eq '');
return $time;
}
# Stores the top N queries generating the biggest temporary file
sub set_top_tempfile_info
{
my ($q, $sz, $date, $db, $user, $remote, $app) = @_;
push(@top_tempfile_info, [($sz, $date, $q, $db, $user, $remote, $app)]);
my @tmp_top_tempfile_info = sort {$b->[0] <=> $a->[0]} @top_tempfile_info;
@top_tempfile_info = ();
for (my $i = 0; $i <= $#tmp_top_tempfile_info; $i++) {
push(@top_tempfile_info, $tmp_top_tempfile_info[$i]);
last if ($i == $end_top);
}
}
# Stores the top N queries cancelled
sub set_top_cancelled_info
{
my ($q, $sz, $date, $db, $user, $remote, $app) = @_;
push(@top_cancelled_info, [($sz, $date, $q, $db, $user, $remote, $app)]);
my @tmp_top_cancelled_info = sort {$b->[0] <=> $a->[0]} @top_cancelled_info;
@top_cancelled_info = ();
for (my $i = 0; $i <= $#tmp_top_cancelled_info; $i++) {
push(@top_cancelled_info, $tmp_top_cancelled_info[$i]);
last if ($i == $end_top);
}
}
# Stores the top N queries waiting the most
sub set_top_locked_info
{
my ($q, $dt, $date, $db, $user, $remote, $app) = @_;
push(@top_locked_info, [($dt, $date, $q, $db, $user, $remote, $app)]);
my @tmp_top_locked_info = sort {$b->[0] <=> $a->[0]} @top_locked_info;
@top_locked_info = ();
for (my $i = 0; $i <= $#tmp_top_locked_info; $i++) {
push(@top_locked_info, $tmp_top_locked_info[$i]);
last if ($i == $end_top);
}
}
# Stores the top N slowest queries
sub set_top_slowest
{
my ($q, $dt, $date, $db, $user, $remote, $app, $bind, $plan) = @_;
push(@top_slowest, [($dt, $date, $q, $db, $user, $remote, $app, $bind, $plan)]);
my @tmp_top_slowest = sort {$b->[0] <=> $a->[0]} @top_slowest;
@top_slowest = ();
for (my $i = 0; $i <= $#tmp_top_slowest; $i++) {
push(@top_slowest, $tmp_top_slowest[$i]);
last if ($i == $end_top);
}
}
# Stores top N slowest sample queries
sub set_top_sample
{
my ($norm, $q, $dt, $date, $db, $user, $remote, $app, $bind, $plan) = @_;
return if (!$norm || !$q);
$normalyzed_info{$norm}{samples}{$dt}{query} = $q;
$normalyzed_info{$norm}{samples}{$dt}{date} = $date;
$normalyzed_info{$norm}{samples}{$dt}{db} = $db;
$normalyzed_info{$norm}{samples}{$dt}{user} = $user;
$normalyzed_info{$norm}{samples}{$dt}{remote} = $remote;
$normalyzed_info{$norm}{samples}{$dt}{app} = $app;
$normalyzed_info{$norm}{samples}{$dt}{bind} = $bind;
$normalyzed_info{$norm}{samples}{$dt}{plan} = $plan;
if ($sample > 0) {
my $i = 1;
foreach my $k (sort {$b <=> $a} keys %{$normalyzed_info{$norm}{samples}}) {
if ($i > $sample) {
delete $normalyzed_info{$norm}{samples}{$k};
}
$i++;
}
}
}
# Stores top N error sample queries
sub set_top_error_sample
{
my ($q, $date, $real_error, $detail, $context, $statement, $hint, $db, $user, $app, $remote, $sqlstate) = @_;
$errors_code{$sqlstate}++ if ($sqlstate);
# Stop when we have our number of samples
if (!exists $error_info{$q}{date} || ($#{$error_info{$q}{date}}+1 < $sample)) {
if ( ($q =~ /deadlock detected/) || ($real_error && !grep(/^\Q$real_error\E$/, @{$error_info{$q}{error}})) ) {
if ($anonymize) {
$context = &anonymize_query($context);
$statement = &anonymize_query($statement);
$detail = &anonymize_query($detail);
}
push(@{$error_info{$q}{date}}, $date);
push(@{$error_info{$q}{detail}}, $detail);
push(@{$error_info{$q}{context}}, $context);
push(@{$error_info{$q}{statement}}, $statement);
push(@{$error_info{$q}{hint}}, $hint);
push(@{$error_info{$q}{error}}, $real_error);
push(@{$error_info{$q}{db}}, $db);
push(@{$error_info{$q}{user}}, $user);
push(@{$error_info{$q}{app}}, $app);
push(@{$error_info{$q}{remote}}, $remote);
push(@{$error_info{$q}{sqlstate}}, $sqlstate);
}
}
}
# Stores top N error sample from pgbouncer log
sub pgb_set_top_error_sample
{
my ($q, $date, $real_error, $db, $user, $remote) = @_;
# Stop when we have our number of samples
if (!exists $pgb_error_info{$q}{date} || ($#{$pgb_error_info{$q}{date}} < $sample)) {
push(@{$pgb_error_info{$q}{date}}, $date);
push(@{$pgb_error_info{$q}{error}}, $real_error);
push(@{$pgb_error_info{$q}{db}}, $db);
push(@{$pgb_error_info{$q}{user}}, $user);
push(@{$pgb_error_info{$q}{remote}}, $remote);
}
}
sub dump_as_text
{
# Global information
my $curdate = localtime(time);
my $fmt_nlines = &comma_numbers($nlines);
my $total_time = timestr($td);
$total_time =~ s/^([\.0-9]+) wallclock.*/$1/;
$total_time = &convert_time($total_time * 1000);
my $logfile_str = $log_files[0];
if ($#log_files > 0) {
$logfile_str .= ', ..., ' . $log_files[-1];
}
print $fh qq{
pgBadger :: $report_title
- Global information ---------------------------------------------------
Generated on $curdate
Log file: $logfile_str
Parsed $fmt_nlines log entries in $total_time
Log start from $overall_stat{'first_log_ts'} to $overall_stat{'last_log_ts'}
};
# Dump normalized queries only if requested
if ($dump_normalized_only) {
print $fh "Count\t\tQuery\n";
print $fh '-'x70,"\n";
foreach my $q (sort { $normalyzed_info{$b}{count} <=> $normalyzed_info{$a}{count} } keys %normalyzed_info) {
print $fh "$normalyzed_info{$q}{count} $q\n";
}
print $fh "\n\n";
print $fh "Report generated by pgBadger $VERSION ($project_url).\n";
return;
}
# Overall statistics
my $fmt_unique = &comma_numbers(scalar keys %normalyzed_info);
my $fmt_queries = &comma_numbers($overall_stat{'queries_number'});
my $fmt_duration = &convert_time($overall_stat{'queries_duration'});
$overall_stat{'first_query_ts'} ||= '-';
$overall_stat{'last_query_ts'} ||= '-';
print $fh qq{
- Overall statistics ---------------------------------------------------
Number of unique normalized queries: $fmt_unique
Number of queries: $fmt_queries
Total query duration: $fmt_duration
First query: $overall_stat{'first_query_ts'}
Last query: $overall_stat{'last_query_ts'}
};
foreach (sort {$overall_stat{'peak'}{$b}{query} <=> $overall_stat{'peak'}{$a}{query}} keys %{$overall_stat{'peak'}}) {
print $fh "Query peak: ", &comma_numbers($overall_stat{'peak'}{$_}{query}), " queries/s at $_";
last;
}
if (!$disable_error) {
my $fmt_errors = &comma_numbers($overall_stat{'errors_number'});
my $fmt_unique_error = &comma_numbers(scalar keys %error_info);
print $fh qq{
Number of events: $fmt_errors
Number of unique normalized events: $fmt_unique_error
};
}
if ($tempfile_info{count}) {
my $fmt_temp_maxsise = &pretty_print_size($tempfile_info{maxsize});
my $fmt_temp_avsize = &pretty_print_size(sprintf("%.2f", ($tempfile_info{size} / $tempfile_info{count})));
print $fh qq{Number temporary files: $tempfile_info{count}
Max size of temporary files: $fmt_temp_maxsise
Average size of temporary files: $fmt_temp_avsize
};
}
if ($cancelled_info{count}) {
print $fh qq{Number cancelled queries: $cancelled_info{count}
};
}
if (!$disable_session && $session_info{count}) {
my $avg_session_duration = &convert_time($session_info{duration} / $session_info{count});
my $tot_session_duration = &convert_time($session_info{duration});
my $avg_queries = &comma_numbers(int($overall_stat{'queries_number'}/$session_info{count}));
my $avg_duration = &convert_time(int($overall_stat{'queries_duration'}/$session_info{count}));
print $fh qq{Total number of sessions: $session_info{count}
Total duration of sessions: $tot_session_duration
Average duration of sessions: $avg_session_duration
Average queries per sessions: $avg_queries
Average queries duration per sessions: $avg_duration
};
foreach (sort {$overall_stat{'peak'}{$b}{session} <=> $overall_stat{'peak'}{$a}{session}} keys %{$overall_stat{'peak'}}) {
next if (!$session_info{count});
print $fh "Session peak: ", &comma_numbers($overall_stat{'peak'}{$_}{session}), " sessions at $_";
last;
}
}
if (!$disable_connection && $connection_info{count}) {
print $fh "Total number of connections: $connection_info{count}\n";
foreach (sort {$overall_stat{'peak'}{$b}{connection} <=> $overall_stat{'peak'}{$a}{connection}} keys %{$overall_stat{'peak'}}) {
if ($overall_stat{'peak'}{$_}{connection} > 0) {
print $fh "Connection peak: ", &comma_numbers($overall_stat{'peak'}{$_}{connection}), " conn/s at $_";
}
last;
}
}
if (scalar keys %database_info > 1) {
print $fh "Total number of databases: ", scalar keys %database_info, "\n";
}
if (!$disable_hourly && $overall_stat{'queries_number'}) {
print $fh qq{
- Hourly statistics ----------------------------------------------------
Report not supported by text format
};
}
# INSERT/DELETE/UPDATE/SELECT repartition
my $totala = 0;
foreach my $a (@SQL_ACTION) {
$totala += $overall_stat{$a};
}
if (!$disable_type && $totala) {
my $total = $overall_stat{'queries_number'} || 1;
print $fh "\n- Queries by type ------------------------------------------------------\n\n";
print $fh "Type Count Percentage\n";
foreach my $a (@SQL_ACTION) {
print $fh "$a: ", &comma_numbers($overall_stat{$a}), " ", sprintf("%0.2f", ($overall_stat{$a} * 100) / $total), "%\n";
}
print $fh "OTHERS: ", &comma_numbers($total - $totala), " ", sprintf("%0.2f", (($total - $totala) * 100) / $total), "%\n"
if (($total - $totala) > 0);
print $fh "\n";
# Show request per database statistics
if (scalar keys %database_info > 1) {
print $fh "\n- Request per database ------------------------------------------------------\n\n";
print $fh "Database Request type Count Duration\n";
foreach my $d (sort keys %database_info) {
print $fh "$d - ", &comma_numbers($database_info{$d}{count}), " ", &convert_time($database_info{$d}{duration}), "\n";
foreach my $r (sort keys %{$database_info{$d}}) {
next if (($r eq 'count') || ($r =~ /duration/));
print $fh "\t$r ", &comma_numbers($database_info{$d}{$r}), " ", &convert_time($database_info{$d}{"$r|duration"}), "\n";
}
}
}
# Show request per application statistics
if (scalar keys %application_info > 1) {
print $fh "\n- Request per application ------------------------------------------------------\n\n";
print $fh "Application Request type Count Duration\n";
foreach my $d (sort keys %application_info) {
print $fh "$d - ", &comma_numbers($application_info{$d}{count}), " ", &convert_time($application_info{$d}{duration}), "\n";
foreach my $r (sort keys %{$application_info{$d}}) {
next if (($r eq 'count') || ($r =~ /duration/));
print $fh "\t$r ", &comma_numbers($application_info{$d}{$r}), " ", &convert_time($application_info{$d}{"$r|duration"}), "\n";
}
}
}
# Show request per user statistics
if (scalar keys %user_info > 1) {
print $fh "\n- Request per user ------------------------------------------------------\n\n";
print $fh "User Request type Count duration\n";
foreach my $d (sort keys %user_info) {
print $fh "$d - ", &comma_numbers($user_info{$d}{count}), " ", &convert_time($user_info{$d}{duration}), "\n";
foreach my $r (sort keys %{$user_info{$d}}) {
next if (($r eq 'count') || ($r =~ /duration/));
print $fh "\t$r ", &comma_numbers($user_info{$d}{$r}), " ", &convert_time($user_info{$d}{"$r|duration"}), "\n";
}
}
}
# Show request per host statistics
if (scalar keys %host_info > 1) {
print $fh "\n- Request per host ------------------------------------------------------\n\n";
print $fh "Host Request type Count Duration\n";
foreach my $d (sort keys %host_info) {
print $fh "$d - ", &comma_numbers($host_info{$d}{count}), " ", &convert_time($host_info{$d}{duration}), "\n";
foreach my $r (sort keys %{$host_info{$d}}) {
next if (($r eq 'count') || ($r =~ /duration/));
print $fh "\t$r ", &comma_numbers($host_info{$d}{$r}), " ", &convert_time($host_info{$d}{"$r|duration"}), "\n";
}
}
}
}
if (!$disable_lock && scalar keys %lock_info > 0) {
print $fh "\n- Locks by type ------------------------------------------------------\n\n";
print $fh "Type Object Count Total Duration Avg duration (s)\n";
my $total_count = 0;
my $total_duration = 0;
foreach my $t (sort keys %lock_info) {
print $fh "$t\t\t", &comma_numbers($lock_info{$t}{count}), " ", &convert_time($lock_info{$t}{duration}), " ",
&convert_time($lock_info{$t}{duration} / $lock_info{$t}{count}), "\n";
foreach my $o (sort keys %{$lock_info{$t}}) {
next if (($o eq 'count') || ($o eq 'duration') || ($o eq 'chronos'));
print $fh "\t$o\t", &comma_numbers($lock_info{$t}{$o}{count}), " ", &convert_time($lock_info{$t}{$o}{duration}), " ",
&convert_time($lock_info{$t}{$o}{duration} / $lock_info{$t}{$o}{count}), "\n";
}
$total_count += $lock_info{$t}{count};
$total_duration += $lock_info{$t}{duration};
}
print $fh "Total:\t\t\t", &comma_numbers($total_count), " ", &convert_time($total_duration), " ",
&convert_time($total_duration / ($total_count || 1)), "\n";
}
# Show session per database statistics
if (!$disable_session && exists $session_info{database}) {
print $fh "\n- Sessions per database ------------------------------------------------------\n\n";
print $fh "Database Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$session_info{database}}) {
print $fh "$d - ", &comma_numbers($session_info{database}{$d}{count}), " ",
&convert_time($session_info{database}{$d}{duration}), " ",
&convert_time($session_info{database}{$d}{duration} / $session_info{database}{$d}{count}), "\n";
}
}
# Show session per user statistics
if (!$disable_session && exists $session_info{user}) {
print $fh "\n- Sessions per user ------------------------------------------------------\n\n";
print $fh "User Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$session_info{user}}) {
print $fh "$d - ", &comma_numbers($session_info{user}{$d}{count}), " ", &convert_time($session_info{user}{$d}{duration}),
" ", &convert_time($session_info{user}{$d}{duration} / $session_info{user}{$d}{count}), "\n";
}
}
# Show session per host statistics
if (!$disable_session && exists $session_info{host}) {
print $fh "\n- Sessions per host ------------------------------------------------------\n\n";
print $fh "User Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$session_info{host}}) {
print $fh "$d - ", &comma_numbers($session_info{host}{$d}{count}), " ", &convert_time($session_info{host}{$d}{duration}),
" ", &convert_time($session_info{host}{$d}{duration} / $session_info{host}{$d}{count}), "\n";
}
}
# Show session per application statistics
if (!$disable_session && exists $session_info{app}) {
print $fh "\n- Sessions per application ------------------------------------------------------\n\n";
print $fh "Application Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$session_info{app}}) {
print $fh "$d - ", &comma_numbers($session_info{app}{$d}{count}), " ", &convert_time($session_info{app}{$d}{duration}),
" ", &convert_time($session_info{app}{$d}{duration} / $session_info{app}{$d}{count}), "\n";
}
}
# Show connection per database statistics
if (!$disable_connection && exists $connection_info{database}) {
print $fh "\n- Connections per database ------------------------------------------------------\n\n";
print $fh "Database User Count\n";
foreach my $d (sort keys %{$connection_info{database}}) {
print $fh "$d - ", &comma_numbers($connection_info{database}{$d}), "\n";
foreach my $u (sort keys %{$connection_info{user}}) {
next if (!exists $connection_info{database_user}{$d}{$u});
print $fh "\t$u ", &comma_numbers($connection_info{database_user}{$d}{$u}), "\n";
}
}
}
# Show connection per user statistics
if (!$disable_connection && exists $connection_info{user}) {
print $fh "\n- Connections per user ------------------------------------------------------\n\n";
print $fh "User Count\n";
foreach my $d (sort keys %{$connection_info{user}}) {
print $fh "$d - ", &comma_numbers($connection_info{user}{$d}), "\n";
}
}
# Show connection per host statistics
if (!$disable_connection && exists $connection_info{host}) {
print $fh "\n- Connections per host ------------------------------------------------------\n\n";
print $fh "User Count\n";
foreach my $d (sort keys %{$connection_info{host}}) {
print $fh "$d - ", &comma_numbers($connection_info{host}{$d}), "\n";
}
}
# Show lock wait detailed information
if (!$disable_lock && scalar keys %lock_info > 0) {
my @top_locked_queries;
foreach my $h (keys %normalyzed_info) {
if (exists($normalyzed_info{$h}{locks})) {
push (@top_locked_queries, [$h, $normalyzed_info{$h}{locks}{count}, $normalyzed_info{$h}{locks}{wait},
$normalyzed_info{$h}{locks}{minwait}, $normalyzed_info{$h}{locks}{maxwait}]);
}
}
# Most frequent waiting queries (N)
@top_locked_queries = sort {$b->[2] <=> $a->[2]} @top_locked_queries;
print $fh "\n- Most frequent waiting queries (N) -----------------------------------------\n\n";
print $fh "Rank Count Total wait time (s) Min/Max/Avg duration (s) Query\n";
for (my $i = 0 ; $i <= $#top_locked_queries ; $i++) {
last if ($i > $end_top);
print $fh ($i + 1), ") ", $top_locked_queries[$i]->[1], " - ", &convert_time($top_locked_queries[$i]->[2]),
" - ", &convert_time($top_locked_queries[$i]->[3]), "/", &convert_time($top_locked_queries[$i]->[4]), "/",
&convert_time(($top_locked_queries[$i]->[2] / $top_locked_queries[$i]->[1])),
" - ", $top_locked_queries[$i]->[0], "\n";
print $fh "--\n";
my $k = $top_locked_queries[$i]->[0];
my $j = 1;
foreach my $d (sort {$b <=> $a} keys %{$normalyzed_info{$k}{samples}}) {
last if ($j > $sample);
my $ttl = $top_locked_info[$i]->[1] || '';
my $db = " - $normalyzed_info{$k}{samples}{$d}{date} - database: $normalyzed_info{$k}{samples}{$d}{db}" if ($normalyzed_info{$k}{samples}{$d}{db});
$db .= ", user: $normalyzed_info{$k}{samples}{$d}{user}" if ($normalyzed_info{$k}{samples}{$d}{user});
$db .= ", remote: $normalyzed_info{$k}{samples}{$d}{remote}" if ($normalyzed_info{$k}{samples}{$d}{remote});
$db .= ", app: $normalyzed_info{$k}{samples}{$d}{app}" if ($normalyzed_info{$k}{samples}{$d}{app});
$db .= ", bind query: yes" if ($normalyzed_info{$k}{samples}{$d}{bind});
$db =~ s/^, / - /;
print $fh "\t- Example $j: ", &convert_time($d), "$db - ", $normalyzed_info{$k}{samples}{$d}{query}, "\n";
$j++;
}
}
print $fh "\n";
@top_locked_queries = ();
# Queries that waited the most
@top_locked_info = sort {$b->[1] <=> $a->[1]} @top_locked_info;
print $fh "\n- Queries that waited the mosts ---------------------------------------------\n\n";
print $fh "Rank Wait time (s) Query\n";
for (my $i = 0 ; $i <= $#top_locked_info ; $i++) {
my $ttl = $top_locked_info[$i]->[1] || '';
my $db = " - database: $top_locked_info[$i]->[3]" if ($top_locked_info[$i]->[3]);
$db .= ", user: $top_locked_info[$i]->[4]" if ($top_locked_info[$i]->[4]);
$db .= ", remote: $top_locked_info[$i]->[5]" if ($top_locked_info[$i]->[5]);
$db .= ", app: $top_locked_info[$i]->[6]" if ($top_locked_info[$i]->[6]);
$db =~ s/^, / - /;
print $fh ($i + 1), ") ", &convert_time($top_locked_info[$i]->[0]),
" $ttl$db - ", $top_locked_info[$i]->[2], "\n";
print $fh "--\n";
}
print $fh "\n";
}
# Show temporary files detailed information
if (!$disable_temporary && scalar keys %tempfile_info > 0) {
my @top_temporary;
foreach my $h (keys %normalyzed_info) {
if (exists($normalyzed_info{$h}{tempfiles})) {
push (@top_temporary, [$h, $normalyzed_info{$h}{tempfiles}{count}, $normalyzed_info{$h}{tempfiles}{size},
$normalyzed_info{$h}{tempfiles}{minsize}, $normalyzed_info{$h}{tempfiles}{maxsize}]);
}
}
# Queries generating the most temporary files (N)
@top_temporary = sort {$b->[1] <=> $a->[1]} @top_temporary;
print $fh "\n- Queries generating the most temporary files (N) ---------------------------\n\n";
print $fh "Rank Count Total size Min/Max/Avg size Query\n";
my $idx = 1;
for (my $i = 0 ; $i <= $#top_temporary ; $i++) {
last if ($i > $end_top);
print $fh $idx, ") ",
$top_temporary[$i]->[1], " - ", &comma_numbers($top_temporary[$i]->[2]),
" - ", &comma_numbers($top_temporary[$i]->[3]),
"/", &comma_numbers($top_temporary[$i]->[4]), "/",
&comma_numbers(sprintf("%.2f", $top_temporary[$i]->[2] / $top_temporary[$i]->[1])),
" - ", $top_temporary[$i]->[0], "\n";
print $fh "--\n";
my $k = $top_temporary[$i]->[0];
if (scalar keys %{$normalyzed_info{$k}{samples}}) {
my $j = 1;
foreach my $d (sort {$b <=> $a} keys %{$normalyzed_info{$k}{samples}}) {
last if ($j > $sample);
my $db = "$normalyzed_info{$k}{samples}{$d}{date} - database: $normalyzed_info{$k}{samples}{$d}{db}" if ($normalyzed_info{$k}{samples}{$d}{db});
$db .= ", user: $normalyzed_info{$k}{samples}{$d}{user}" if ($normalyzed_info{$k}{samples}{$d}{user});
$db .= ", remote: $normalyzed_info{$k}{samples}{$d}{remote}" if ($normalyzed_info{$k}{samples}{$d}{remote});
$db .= ", app: $normalyzed_info{$k}{samples}{$d}{app}" if ($normalyzed_info{$k}{samples}{$d}{app});
$db .= ", bind query: yes" if ($normalyzed_info{$k}{samples}{$d}{bind});
$db =~ s/^, / - /;
print $fh "\t- Example $j: ", &convert_time($d), " - $db - ", $normalyzed_info{$k}{samples}{$d}{query}, "\n";
$j++;
}
}
$idx++;
}
@top_temporary = ();
# Top queries generating the largest temporary files
@top_tempfile_info = sort {$b->[1] <=> $a->[1]} @top_tempfile_info;
print $fh "\n- Queries generating the largest temporary files ----------------------------\n\n";
print $fh "Rank Size Query\n";
for (my $i = 0 ; $i <= $#top_tempfile_info ; $i++) {
my $ttl = $top_tempfile_info[$i]->[1] || '';
my $db = " - database: $top_tempfile_info[$i]->[3]" if ($top_tempfile_info[$i]->[3]);
$db .= ", user: $top_tempfile_info[$i]->[4]" if ($top_tempfile_info[$i]->[4]);
$db .= ", remote: $top_tempfile_info[$i]->[5]" if ($top_tempfile_info[$i]->[5]);
$db .= ", app: $top_tempfile_info[$i]->[6]" if ($top_tempfile_info[$i]->[6]);
$db =~ s/^, / - /;
print $fh ($i + 1), ") ", &comma_numbers($top_tempfile_info[$i]->[0]),
" - $ttl$db - ", $top_tempfile_info[$i]->[2], "\n";
}
print $fh "\n";
}
# Show cancelled queries detailed information
if (!$disable_query && scalar keys %cancelled_info > 0) {
my @top_cancelled;
foreach my $h (keys %normalyzed_info) {
if (exists($normalyzed_info{$h}{cancelled})) {
push (@top_cancelled, [$h, $normalyzed_info{$h}{cancelled}{count}]);
}
}
# Queries generating the most cancelled files (N)
@top_cancelled = sort {$b->[1] <=> $a->[1]} @top_cancelled;
print $fh "\n- Queries most cancelled (N) ---------------------------\n\n";
print $fh "Rank Count Query\n";
my $idx = 1;
for (my $i = 0 ; $i <= $#top_cancelled ; $i++) {
last if ($i > $end_top);
print $fh $idx, ") ",
$top_cancelled[$i]->[1], " - ", $top_cancelled[$i]->[0], "\n";
print $fh "--\n";
my $k = $top_cancelled[$i]->[0];
if (scalar keys %{$normalyzed_info{$k}{samples}}) {
my $j = 1;
foreach my $d (sort {$b <=> $a} keys %{$normalyzed_info{$k}{samples}}) {
last if ($j > $sample);
my $db = "$normalyzed_info{$k}{samples}{$d}{date} - database: $normalyzed_info{$k}{samples}{$d}{db}" if ($normalyzed_info{$k}{samples}{$d}{db});
$db .= ", user: $normalyzed_info{$k}{samples}{$d}{user}" if ($normalyzed_info{$k}{samples}{$d}{user});
$db .= ", remote: $normalyzed_info{$k}{samples}{$d}{remote}" if ($normalyzed_info{$k}{samples}{$d}{remote});
$db .= ", app: $normalyzed_info{$k}{samples}{$d}{app}" if ($normalyzed_info{$k}{samples}{$d}{app});
$db .= ", bind query: yes" if ($normalyzed_info{$k}{samples}{$d}{bind});
$db =~ s/^, / - /;
print $fh "\t- Example $j: ", &convert_time($d), " - $db - ", $normalyzed_info{$k}{samples}{$d}{query}, "\n";
$j++;
}
}
$idx++;
}
@top_cancelled = ();
# Top queries generating the largest cancelled files
@top_cancelled_info = sort {$b->[1] <=> $a->[1]} @top_cancelled_info;
print $fh "\n- Queries generating the most cancellation ----------------------------\n\n";
print $fh "Rank Times cancelled Query\n";
for (my $i = 0 ; $i <= $#top_cancelled_info ; $i++) {
my $ttl = $top_cancelled_info[$i]->[1] || '';
my $db = " - database: $top_cancelled_info[$i]->[3]" if ($top_cancelled_info[$i]->[3]);
$db .= ", user: $top_cancelled_info[$i]->[4]" if ($top_cancelled_info[$i]->[4]);
$db .= ", remote: $top_cancelled_info[$i]->[5]" if ($top_cancelled_info[$i]->[5]);
$db .= ", app: $top_cancelled_info[$i]->[6]" if ($top_cancelled_info[$i]->[6]);
$db =~ s/^, / - /;
print $fh ($i + 1), ") ", &comma_numbers($top_cancelled_info[$i]->[0]),
" - $ttl$db - ", $top_cancelled_info[$i]->[2], "\n";
}
print $fh "\n";
}
# Show top information
if (!$disable_query && ($#top_slowest >= 0)) {
print $fh "\n- Slowest queries ------------------------------------------------------\n\n";
print $fh "Rank Duration (s) Query\n";
for (my $i = 0 ; $i <= $#top_slowest ; $i++) {
my $db = " database: $top_slowest[$i]->[3]" if ($top_slowest[$i]->[3]);
$db .= ", user: $top_slowest[$i]->[4]" if ($top_slowest[$i]->[4]);
$db .= ", remote: $top_slowest[$i]->[5]" if ($top_slowest[$i]->[5]);
$db .= ", app: $top_slowest[$i]->[6]" if ($top_slowest[$i]->[6]);
$db .= ", bind query: yes" if ($top_slowest[$i]->[7]);
$db =~ s/^, //;
print $fh $i + 1, ") " . &convert_time($top_slowest[$i]->[0]) . "$db - $top_slowest[$i]->[2]\n";
print $fh "--\n";
}
print $fh "\n- Queries that took up the most time (N) -------------------------------\n\n";
print $fh "Rank Total duration Times executed Min/Max/Avg duration (s) Query\n";
my $idx = 1;
foreach my $k (sort {$normalyzed_info{$b}{duration} <=> $normalyzed_info{$a}{duration}} keys %normalyzed_info) {
next if (!$normalyzed_info{$k}{count});
last if ($idx > $top);
my $q = $k;
if ($normalyzed_info{$k}{count} == 1) {
foreach (keys %{$normalyzed_info{$k}{samples}}) {
$q = $normalyzed_info{$k}{samples}{$_}{query};
last;
}
}
$normalyzed_info{$k}{average} = $normalyzed_info{$k}{duration} / $normalyzed_info{$k}{count};
print $fh "$idx) "
. &convert_time($normalyzed_info{$k}{duration}) . " - "
. &comma_numbers($normalyzed_info{$k}{count}) . " - "
. &convert_time($normalyzed_info{$k}{min}) . "/"
. &convert_time($normalyzed_info{$k}{max}) . "/"
. &convert_time($normalyzed_info{$k}{average})
. " - $q\n";
print $fh "--\n";
my $j = 1;
foreach my $d (sort {$b <=> $a} keys %{$normalyzed_info{$k}{samples}}) {
last if ($j > $sample);
my $db = " - database: $normalyzed_info{$k}{samples}{$d}{db}" if ($normalyzed_info{$k}{samples}{$d}{db});
$db .= ", user: $normalyzed_info{$k}{samples}{$d}{user}" if ($normalyzed_info{$k}{samples}{$d}{user});
$db .= ", remote: $normalyzed_info{$k}{samples}{$d}{remote}" if ($normalyzed_info{$k}{samples}{$d}{remote});
$db .= ", app: $normalyzed_info{$k}{samples}{$d}{app}" if ($normalyzed_info{$k}{samples}{$d}{app});
$db .= ", bind query: yes" if ($normalyzed_info{$k}{samples}{$d}{bind});
$db =~ s/^, / - /;
print $fh "\t- Example $j: ", &convert_time($d), "$db - ", $normalyzed_info{$k}{samples}{$d}{query}, "\n";
$j++;
}
$idx++;
}
}
if (!$disable_query && (scalar keys %normalyzed_info > 0)) {
print $fh "\n- Most frequent queries (N) --------------------------------------------\n\n";
print $fh "Rank Times executed Total duration Min/Max/Avg duration (s) Query\n";
my $idx = 1;
foreach my $k (sort {$normalyzed_info{$b}{count} <=> $normalyzed_info{$a}{count}} keys %normalyzed_info) {
next if (!$normalyzed_info{$k}{count});
last if ($idx > $top);
my $q = $k;
if ($normalyzed_info{$k}{count} == 1) {
foreach (keys %{$normalyzed_info{$k}{samples}}) {
$q = $normalyzed_info{$k}{samples}{$_}{query};
last;
}
}
print $fh "$idx) "
. &comma_numbers($normalyzed_info{$k}{count}) . " - "
. &convert_time($normalyzed_info{$k}{duration}) . " - "
. &convert_time($normalyzed_info{$k}{min}) . "/"
. &convert_time($normalyzed_info{$k}{max}) . "/"
. &convert_time($normalyzed_info{$k}{duration} / $normalyzed_info{$k}{count})
. " - $q\n";
print $fh "--\n";
my $i = 1;
foreach my $d (sort {$b <=> $a} keys %{$normalyzed_info{$k}{samples}}) {
last if ($i > $sample);
my $db = " - database: $normalyzed_info{$k}{samples}{$d}{db}" if ($normalyzed_info{$k}{samples}{$d}{db});
$db .= ", user: $normalyzed_info{$k}{samples}{$d}{user}" if ($normalyzed_info{$k}{samples}{$d}{user});
$db .= ", remote: $normalyzed_info{$k}{samples}{$d}{remote}" if ($normalyzed_info{$k}{samples}{$d}{remote});
$db .= ", app: $normalyzed_info{$k}{samples}{$d}{app}" if ($normalyzed_info{$k}{samples}{$d}{app});
$db .= ", bind query: yes" if ($normalyzed_info{$k}{samples}{$d}{bind});
$db =~ s/^, / - /;
print $fh "\tExample $i: ", &convert_time($d), "$db - ", $normalyzed_info{$k}{samples}{$d}{query}, "\n";
$i++;
}
$idx++;
}
}
if (!$disable_query && ($#top_slowest >= 0)) {
print $fh "\n- Slowest queries (N) --------------------------------------------------\n\n";
print $fh "Rank Min/Max/Avg duration (s) Times executed Total duration Query\n";
my $idx = 1;
foreach my $k (sort {$normalyzed_info{$b}{average} <=> $normalyzed_info{$a}{average}} keys %normalyzed_info) {
next if (!$normalyzed_info{$k}{count});
last if ($idx > $top);
my $q = $k;
if ($normalyzed_info{$k}{count} == 1) {
foreach (keys %{$normalyzed_info{$k}{samples}}) {
$q = $normalyzed_info{$k}{samples}{$_}{query};
last;
}
}
print $fh "$idx) "
. &convert_time($normalyzed_info{$k}{min}) . "/"
. &convert_time($normalyzed_info{$k}{max}) . "/"
. &convert_time($normalyzed_info{$k}{average}) . " - "
. &comma_numbers($normalyzed_info{$k}{count}) . " - "
. &convert_time($normalyzed_info{$k}{duration})
. " - $q\n";
print $fh "--\n";
my $i = 1;
foreach my $d (sort {$b <=> $a} keys %{$normalyzed_info{$k}{samples}}) {
last if ($i > $sample);
my $db = " - database: $normalyzed_info{$k}{samples}{$d}{db}" if ($normalyzed_info{$k}{samples}{$d}{db});
$db .= ", user: $normalyzed_info{$k}{samples}{$d}{user}" if ($normalyzed_info{$k}{samples}{$d}{user});
$db .= ", remote: $normalyzed_info{$k}{samples}{$d}{remote}" if ($normalyzed_info{$k}{samples}{$d}{remote});
$db .= ", app: $normalyzed_info{$k}{samples}{$d}{app}" if ($normalyzed_info{$k}{samples}{$d}{app});
$db .= ", bind query: yes" if ($normalyzed_info{$k}{samples}{$d}{yes});
$db =~ s/^, / - /;
print $fh "\tExample $i: ", &convert_time($d), "$db - ", $normalyzed_info{$k}{samples}{$d}{query}, "\n";
$i++;
}
$idx++;
}
}
@top_slowest = ();
if (!$disable_error) {
&show_error_as_text();
}
# Show pgbouncer session per database statistics
if (exists $pgb_session_info{database}) {
print $fh "\n- pgBouncer sessions per database --------------------------------------------\n\n";
print $fh "Database Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$pgb_session_info{database}}) {
print $fh "$d - ", &comma_numbers($pgb_session_info{database}{$d}{count}), " ",
&convert_time($pgb_session_info{database}{$d}{duration}), " ",
&convert_time($pgb_session_info{database}{$d}{duration} / $pgb_session_info{database}{$d}{count}), "\n";
}
}
# Show pgbouncer session per user statistics
if (exists $pgb_session_info{user}) {
print $fh "\n- pgBouncer sessions per user ------------------------------------------------\n\n";
print $fh "User Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$pgb_session_info{user}}) {
print $fh "$d - ", &comma_numbers($pgb_session_info{user}{$d}{count}), " ", &convert_time($pgb_session_info{user}{$d}{duration}),
" ", &convert_time($pgb_session_info{user}{$d}{duration} / $pgb_session_info{user}{$d}{count}), "\n";
}
}
# Show pgbouncer session per host statistics
if (exists $pgb_session_info{host}) {
print $fh "\n- pgBouncer sessions per host ------------------------------------------------\n\n";
print $fh "User Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$pgb_session_info{host}}) {
print $fh "$d - ", &comma_numbers($pgb_session_info{host}{$d}{count}), " ", &convert_time($pgb_session_info{host}{$d}{duration}),
" ", &convert_time($pgb_session_info{host}{$d}{duration} / $pgb_session_info{host}{$d}{count}), "\n";
}
}
# Show pgbouncer session per application statistics
if (exists $pgb_session_info{app}) {
print $fh "\n- pgBouncer sessions per application -----------------------------------------\n\n";
print $fh "Application Count Total Duration Avg duration (s)\n";
foreach my $d (sort keys %{$pgb_session_info{app}}) {
print $fh "$d - ", &comma_numbers($pgb_session_info{app}{$d}{count}), " ", &convert_time($pgb_session_info{app}{$d}{duration}),
" ", &convert_time($pgb_session_info{app}{$d}{duration} / $pgb_session_info{app}{$d}{count}), "\n";
}
}
# Show pgbouncer connection per database statistics
if (exists $pgb_connection_info{database}) {
print $fh "\n- pgBouncer connections per database -----------------------------------------\n\n";
print $fh "Database User Count\n";
foreach my $d (sort keys %{$pgb_connection_info{database}}) {
print $fh "$d - ", &comma_numbers($pgb_connection_info{database}{$d}), "\n";
foreach my $u (sort keys %{$pgb_connection_info{user}}) {
next if (!exists $pgb_connection_info{database_user}{$d}{$u});
print $fh "\t$u ", &comma_numbers($pgb_connection_info{database_user}{$d}{$u}), "\n";
}
}
}
# Show pgbouncer connection per user statistics
if (exists $pgb_connection_info{user}) {
print $fh "\n- pgBouncer connections per user ---------------------------------------------\n\n";
print $fh "User Count\n";
foreach my $d (sort keys %{$pgb_connection_info{user}}) {
print $fh "$d - ", &comma_numbers($pgb_connection_info{user}{$d}), "\n";
}
}
# Show pgbouncer connection per host statistics
if (exists $pgb_connection_info{host}) {
print $fh "\n- pgBouncer connections per host --------------------------------------------\n\n";
print $fh "User Count\n";
foreach my $d (sort keys %{$pgb_connection_info{host}}) {
print $fh "$d - ", &comma_numbers($pgb_connection_info{host}{$d}), "\n";
}
}
if (!$disable_error) {
&show_pgb_error_as_text();
}
print $fh "\n\n";
print $fh "Report generated by pgBadger $VERSION ($project_url).\n";
}
sub dump_error_as_text
{
# Global information
my $curdate = localtime(time);
my $fmt_nlines = &comma_numbers($nlines);
my $total_time = timestr($td);
$total_time =~ s/^([\.0-9]+) wallclock.*/$1/;
$total_time = &convert_time($total_time * 1000);
my $logfile_str = $log_files[0];
if ($#log_files > 0) {
$logfile_str .= ', ..., ' . $log_files[-1];
}
$report_title ||= 'PostgreSQL Log Analyzer';
print $fh qq{
pgBadger :: $report_title
- Global information ---------------------------------------------------
Generated on $curdate
Log file: $logfile_str
Parsed $fmt_nlines log entries in $total_time
Log start from $overall_stat{'first_log_ts'} to $overall_stat{'last_log_ts'}
};
&show_error_as_text();
print $fh "\n\n";
&show_pgb_error_as_text();
print $fh "\n\n";
print $fh "Report generated by pgBadger $VERSION ($project_url).\n";
}
# We change temporary log level from LOG to ERROR
# to store these messages into the error report
sub change_log_level
{
my $msg = shift;
return 1 if ($msg =~ /parameter "[^"]+" changed to "[^"]+"/);
return 1 if ($msg =~ /database system was/);
return 1 if ($msg =~ /recovery has paused/);
return 1 if ($msg =~ /ending cancel to blocking autovacuum/);
return 1 if ($msg =~ /skipping analyze of/);
return 1 if ($msg =~ /using stale statistics/);
return 1 if ($msg =~ /replication command:/);
return 1 if ($msg =~ /still waiting for/);
return 0;
}
sub revert_log_level
{
my $msg = shift;
return ($msg, 1) if ($msg =~ s/ERROR: (parameter "[^"]+" changed to)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (database system was)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (recovery has paused)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (sending cancel to blocking autovacuum)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (skipping analyze of)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (using stale statistics)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (received replication command:)/LOG: $1/);
return ($msg, 1) if ($msg =~ s/ERROR: (.*still waiting for)/LOG: $1/);
return ($msg, 0);
}
sub show_error_as_text
{
return if (scalar keys %error_info == 0);
print $fh "\n- Most frequent events (N) ---------------------------------------------\n\n";
my $idx = 1;
foreach my $k (sort {$error_info{$b}{count} <=> $error_info{$a}{count}} keys %error_info) {
next if (!$error_info{$k}{count});
last if ($idx > $top);
last if (!$error_info{$k}{count});
my ($msg, $ret) = &revert_log_level($k);
if ($error_info{$k}{count} > 1) {
print $fh "$idx) " . &comma_numbers($error_info{$k}{count}) . " - $msg\n";
print $fh "--\n";
my $j = 1;
for (my $i = 0 ; $i <= $#{$error_info{$k}{date}} ; $i++) {
last if ($i == $sample);
($error_info{$k}{error}[$i], $ret) = &revert_log_level($error_info{$k}{error}[$i]);
if ($msg) {
$logs_type{ERROR}--;
$logs_type{LOG}++;
}
print $fh "\t- Example $j: $error_info{$k}{date}[$i] - $error_info{$k}{error}[$i]\n";
print $fh "\t\tDetail: $error_info{$k}{detail}[$i]\n" if ($error_info{$k}{detail}[$i]);
print $fh "\t\tContext: $error_info{$k}{context}[$i]\n" if ($error_info{$k}{context}[$i]);
print $fh "\t\tHint: $error_info{$k}{hint}[$i]\n" if ($error_info{$k}{hint}[$i]);
print $fh "\t\tStatement: $error_info{$k}{statement}[$i]\n" if ($error_info{$k}{statement}[$i]);
print $fh "\t\tDatabase: $error_info{$k}{db}[$i]\n" if ($error_info{$k}{db}[$i]);
$j++;
}
} elsif ($error_info{$k}{error}[0]) {
($error_info{$k}{error}[0], $ret) = &revert_log_level($error_info{$k}{error}[0]);
if ($msg) {
$logs_type{ERROR}--;
$logs_type{LOG}++;
}
if ($sample) {
print $fh "$idx) " . &comma_numbers($error_info{$k}{count}) . " - $error_info{$k}{error}[0]\n";
print $fh "--\n";
print $fh "\t- Date: $error_info{$k}{date}[0]\n";
print $fh "\t\tDetail: $error_info{$k}{detail}[0]\n" if ($error_info{$k}{detail}[0]);
print $fh "\t\tContext: $error_info{$k}{context}[0]\n" if ($error_info{$k}{context}[0]);
print $fh "\t\tHint: $error_info{$k}{hint}[0]\n" if ($error_info{$k}{hint}[0]);
print $fh "\t\tStatement: $error_info{$k}{statement}[0]\n" if ($error_info{$k}{statement}[0]);
print $fh "\t\tDatabase: $error_info{$k}{db}[0]\n" if ($error_info{$k}{db}[0]);
} else {
print $fh "$idx) " . &comma_numbers($error_info{$k}{count}) . " - $msg\n";
print $fh "--\n";
}
}
$idx++;
}
if (scalar keys %logs_type > 0) {
print $fh "\n- Logs per type ---------------------------------------------\n\n";
my $total_logs = 0;
foreach my $d (keys %logs_type) {
$total_logs += $logs_type{$d};
}
print $fh "Logs type Count Percentage\n";
foreach my $d (sort keys %logs_type) {
next if (!$logs_type{$d});
print $fh "$d\t\t", &comma_numbers($logs_type{$d}), "\t", sprintf("%0.2f", ($logs_type{$d} * 100) / $total_logs), "%\n";
}
}
if (scalar keys %errors_code > 0) {
print $fh "\n- Logs per type ---------------------------------------------\n\n";
my $total_logs = 0;
foreach my $d (keys %errors_code) {
$total_logs += $errors_code{$d};
}
print $fh "Errors class code Count Percentage\n";
foreach my $d (sort keys %errors_code) {
next if (!$errors_code{$d});
print $fh "$CLASS_ERROR_CODE{$d}\t$d\t\t", &comma_numbers($errors_code{$d}), "\t", sprintf("%0.2f", ($errors_code{$d} * 100) / $total_logs), "%\n";
}
}
}
sub show_pgb_error_as_text
{
return if (scalar keys %pgb_error_info == 0);
print $fh "\n- Most frequent events (N) ---------------------------------------------\n\n";
my $idx = 1;
foreach my $k (sort {$pgb_error_info{$b}{count} <=> $pgb_error_info{$a}{count}} keys %pgb_error_info) {
next if (!$pgb_error_info{$k}{count});
last if ($idx > $top);
my $msg = $k;
if ($pgb_error_info{$k}{count} > 1) {
print $fh "$idx) " . &comma_numbers($pgb_error_info{$k}{count}) . " - $msg\n";
print $fh "--\n";
my $j = 1;
for (my $i = 0 ; $i <= $#{$pgb_error_info{$k}{date}} ; $i++) {
last if ($i == $sample);
print $fh "\t- Example $j: $pgb_error_info{$k}{date}[$i] - $pgb_error_info{$k}{error}[$i]\n";
print $fh "\t\tDatabase: $pgb_error_info{$k}{db}[$i]\n" if ($pgb_error_info{$k}{db}[$i]);
print $fh "\t\tUser: $pgb_error_info{$k}{user}[$i]\n" if ($pgb_error_info{$k}{user}[$i]);
print $fh "\t\tClient: $pgb_error_info{$k}{remote}[$i]\n" if ($pgb_error_info{$k}{remote}[$i]);
$j++;
}
} else {
if ($sample) {
print $fh "$idx) " . &comma_numbers($pgb_error_info{$k}{count}) . " - $pgb_error_info{$k}{error}[0]\n";
print $fh "--\n";
print $fh "\t- Date: $pgb_error_info{$k}{date}[0]\n";
print $fh "\t\tDatabase: $pgb_error_info{$k}{db}[0]\n" if ($pgb_error_info{$k}{db}[0]);
print $fh "\t\tUser: $pgb_error_info{$k}{user}[0]\n" if ($pgb_error_info{$k}{user}[0]);
print $fh "\t\tClient: $pgb_error_info{$k}{remote}[0]\n" if ($pgb_error_info{$k}{remote}[0]);
} else {
print $fh "$idx) " . &comma_numbers($pgb_error_info{$k}{count}) . " - $msg\n";
print $fh "--\n";
}
}
$idx++;
}
}
sub html_header
{
my $uri = shift;
my $date = localtime(time);
my $global_info = &print_global_information();
my @tmpjscode = @jscode;
map { s/EDIT_URI/$uri/; } @tmpjscode;
my $local_title = 'PostgreSQL Log Analyzer';
if ($report_title) {
$local_title = $report_title;
}
$report_title ||= 'pgBadger';
print $fh qq{
-
};
}
sub html_footer
{
print $fh qq{
Right click + "Save image as ..." to save the graph as PNG image
- Generated on $curdate
- Log file: $logfile_str
- Parsed $fmt_nlines log entries in $total_time
- Log start from $overall_stat{'first_log_ts'} to $overall_stat{'last_log_ts'}
Overview
Global Stats
- $fmt_unique Number of unique normalized queries
- $fmt_queries Number of queries
- $fmt_duration Total query duration
- $overall_stat{'first_query_ts'} First query
- $overall_stat{'last_query_ts'} Last query
- $query_peak queries/s at $query_peak_date Query peak
- $fmt_errors Number of events
- $fmt_unique_error Number of unique normalized events
- $main_error Max number of times the same event was reported
- $cancelled_count Number of cancellation
- $autovacuum_count Total number of automatic vacuums
- $autoanalyze_count Total number of automatic analyzes
- $tempfile_count Number temporary file
- $fmt_temp_maxsise Max size of temporary file
- $fmt_temp_avsize Average size of temporary file
- $session_count Total number of sessions
- $session_peak sessions at $session_peak_date Session peak
- $tot_session_duration Total duration of sessions
- $avg_session_duration Average duration of sessions
- $avg_queries Average queries per session
- $avg_duration Average queries duration per session
- $connection_count Total number of connections }; if ($connection_count) { print $fh qq{
- $connection_peak connections/s at $connection_peak_date Connection peak }; } print $fh qq{
- $db_count Total number of databases
General Activity
| Day | Hour | Count | Min duration | Max duration | Avg duration | Latency Percentile(90) | Latency Percentile(95) | Latency Percentile(99) |
|---|
| Day | Hour | SELECT | COPY TO | Average Duration | Latency Percentile(90) | Latency Percentile(95) | Latency Percentile(99) |
|---|
| Day | Hour | INSERT | UPDATE | DELETE | COPY FROM | Average Duration | Latency Percentile(90) | Latency Percentile(95) | Latency Percentile(99) |
|---|
| Day | Hour | Prepare | Bind | Bind/Prepare | Percentage of prepare |
|---|
| Day | Hour | Count | Average / Second |
|---|
| Day | Hour | Count | Average Duration |
|---|
SQL Traffic
Key values
- $query_peak queries/s Query Peak
- $query_peak_date Date
$drawn_graphs{queriespersecond_graph}
SELECT Traffic
Key values
- $select_peak queries/s Query Peak
- $select_peak_date Date
$drawn_graphs{selectqueries_graph}
INSERT/UPDATE/DELETE Traffic
Key values
- $write_peak queries/s Query Peak
- $write_peak_date Date
$drawn_graphs{writequeries_graph}
Queries duration
Key values
- $fmt_duration Total query duration
$drawn_graphs{durationqueries_graph}
Prepared queries ratio
Key values
- $bind_vs_prepared Ratio of bind vs prepare
- $prepared_vs_normal % Ratio between prepared and "usual" statements
$drawn_graphs{bindpreparequeries_graph}
Request Throughput
Key values
- $request_peak queries/s Request Peak
- $request_peak_date Date
$drawn_graphs{pgb_requestpersecond_graph}
Bytes I/O Throughput
Key values
- $inbytes_peak Bytes/s In Bytes Peak
- $inbytes_peak_date Date
- $outbytes_peak Bytes/s Out Bytes Peak
- $outbytes_peak_date Date
$drawn_graphs{pgb_bytepersecond_graph}
Queries Average duration
Key values
- $avgduration_peak Average Duration Peak
- $avgduration_peak_date Date
$drawn_graphs{pgb_avgduration_graph}
Established Connections
Key values
- $connection_peak connections Connection Peak
- $connection_peak_date Date
$drawn_graphs{connectionspersecond_graph}
Established Connections
Key values
- $connection_peak connections Connection Peak
- $connection_peak_date Date
$drawn_graphs{pgb_connectionspersecond_graph}
Connections per user
Key values
- $main_user[0] Main User
- $total_count connections Total
$drawn_graphs{userconnections_graph}
| User | Count |
|---|
Connections per user
Key values
- $main_user[0] Main User
- $total_count connections Total
$drawn_graphs{pgb_userconnections_graph}
| User | Count |
|---|
Connections per host
Key values
- $main_host[0] Main host with $main_host[1] connections
- $total_count Total connections
$drawn_graphs{hostconnections_graph}
| Host | Count |
|---|
Connections per host
Key values
- $main_host[0] Main host with $main_host[1] connections
- $total_count Total connections
$drawn_graphs{pgb_hostconnections_graph}
| Host | Count |
|---|
Connections per database
Key values
- $main_database[0] Main Database
- $total_count connections Total
$drawn_graphs{databaseconnections_graph}
| Database | User | Count |
|---|
Connections per database
Key values
- $main_database[0] Main Database
- $total_count connections Total
$drawn_graphs{pgb_databaseconnections_graph}
| Database | User | Count |
|---|
Simultaneous sessions
Key values
- $session_peak sessions Session Peak
- $session_peak_date Date
$drawn_graphs{sessionspersecond_graph}
Simultaneous sessions
Key values
- $session_peak sessions Session Peak
- $session_peak_date Date
$drawn_graphs{pgb_sessionspersecond_graph}
Histogram of session times
Key values
- $most_range_value $most_range duration
$drawn_graphs{histogram_session_times_graph}
| Range | Count | Percentage |
|---|
Histogram of session times
Key values
- $most_range_value $most_range duration
$drawn_graphs{pgb_histogram_session_times_graph}
| Range | Count | Percentage |
|---|
Sessions per user
Key values
- $main_user[0] Main User
- $total_count sessions Total
$drawn_graphs{usersessions_graph}
| User | Count | Total Duration | Average Duration |
|---|
Sessions per user
Key values
- $main_user[0] Main User
- $total_count sessions Total
$drawn_graphs{pgb_usersessions_graph}
| User | Count | Total Duration | Average Duration |
|---|
Sessions per host
Key values
- $main_host[0] Main Host
- $total_count sessions Total
$drawn_graphs{hostsessions_graph}
| Host | Count | Total Duration | Average Duration |
|---|
Sessions per host
Key values
- $main_host[0] Main Host
- $total_count sessions Total
$drawn_graphs{pgb_hostsessions_graph}
| Host | Count | Total Duration | Average Duration |
|---|
Sessions per application
Key values
- $main_app[0] Main Host
- $total_count sessions Total
$drawn_graphs{appsessions_graph}
| Application | Count | Total Duration | Average Duration |
|---|
Sessions per database
Key values
- $main_database[0] Main Database
- $total_count sessions Total
$drawn_graphs{databasesessions_graph}
| Database | User | Count | Total Duration | Average Duration |
|---|
Sessions per database
Key values
- $main_database[0] Main Database
- $total_count sessions Total
$drawn_graphs{pgb_databasesessions_graph}
| Database | User | Count | Total Duration | Average Duration |
|---|
Checkpoints / Restartpoints
Checkpoints Buffers
Key values
- $checkpoint_wbuffer_peak buffers Checkpoint Peak
- $checkpoint_wbuffer_peak_date Date
- $overall_checkpoint{checkpoint_write} seconds Highest write time
- $overall_checkpoint{checkpoint_sync} seconds Sync time
$drawn_graphs{checkpointwritebuffers_graph}
Checkpoints Wal files
Key values
- $walfile_usage_peak files Wal files usage Peak
- $walfile_usage_peak_date Date
$drawn_graphs{checkpointfiles_graph}
Checkpoints distance
Key values
$drawn_graphs{checkpointdistance_graph}
Checkpoints Activity
| Day | Hour | Written buffers | Write time | Sync time | Total time |
|---|
| Day | Hour | Added | Removed | Recycled | Synced files | Longest sync | Average sync |
|---|
| Day | Hour | Count | Avg time (sec) |
|---|
| Day | Hour | Mean distance | Mean estimate |
|---|
Temporary Files
Size of temporary files
Key values
- $tempfile_size_peak Temp Files size Peak
- $tempfile_size_peak_date Date
$drawn_graphs{temporarydata_graph}
Number of temporary files
Key values
- $tempfile_count_peak per second Temp Files Peak
- $tempfile_count_peak_date Date
$drawn_graphs{temporaryfile_graph}
Temporary Files Activity
| Day | Hour | Count | Total size | Average size |
|---|
Number of cancelled queries
Key values
- $cancelled_count_peak per second Cancelled query Peak
- $cancelled_count_peak_date Date
$drawn_graphs{cancelledqueries_graph}
Analyzes per table
Key values
- $main_analyze[0] ($main_analyze[1]) Main table analyzed (database $database)
- $total_count analyzes Total
$drawn_graphs{tableanalyzes_graph}
| Table | Number of analyzes |
|---|
Vacuums
Vacuums / Analyzes Distribution
Key values
- $autovacuum_info{peak}{system_usage}{elapsed} sec Highest CPU-cost vacuum
Table $autovacuum_info{peak}{system_usage}{table}
Database $autovacuum_peak_system_usage_db - $autovacuum_info{peak}{system_usage}{date} Date
- $autoanalyze_info{peak}{system_usage}{elapsed} sec Highest CPU-cost analyze
Table $autoanalyze_info{peak}{system_usage}{table}
Database $autovacuum_peak_system_usage_db - $autoanalyze_info{peak}{system_usage}{date} Date
$drawn_graphs{autovacuum_graph}
Autovacuum Activity
| Day | Hour | VACUUMs | ANALYZEs |
|---|
Vacuums per table
Key values
- $main_vacuum[0] ($main_vacuum[1]) Main table vacuumed on database $database
- $total_count vacuums Total
$drawn_graphs{tablevacuums_graph}
| Table | Number of vacuums | Index scans |
|---|
Tuples removed per table
Key values
- $main_tuple[0] ($main_tuple[1]) Main table with removed tuples on database $database
- $total_tuple tuples Total removed
$drawn_graphs{tuplevacuums_graph}
| Table | Number of vacuums | Index scans | Tuples removed | Pages removed |
|---|
Pages removed per table
Key values
- $main_page[0] ($main_page[1]) Main table with removed pages on database $database
- $total_page pages Total removed
$drawn_graphs{pagevacuums_graph}
| Table | Number of vacuums | Index scans | Tuples removed | Pages removed |
|---|
Locks
Locks by types
Key values
- $main_locktype[0] Main Lock Type
- $total_count locks Total
$drawn_graphs{lockbytype_graph}
| Type | Object | Count | Total Duration | Average Duration (s) |
|---|
Queries
Queries by type
Key values
- $total_select Total read queries
- $total_write Total write queries
$drawn_graphs{queriesbytype_graph}
| Type | Count | Percentage |
|---|
Queries by database
Key values
- $main_database[0] Main database
- $main_database[1] Requests
- $main_database_duration[1] ($main_database_duration[0])
- Main time consuming database
$drawn_graphs{queriesbydatabase_graph}
| Database | Request type | Count | Duration |
|---|
Queries by application
Key values
- $main_application[0] Main application
- $main_application[1] Requests
- $main_application_duration[1] ($main_application_duration[0])
- Main time consuming application
$drawn_graphs{queriesbyapplication_graph}
| Application | Request type | Count | Duration |
|---|
Queries by user
Key values
- $main_user[0] Main user
- $main_user[1] Requests
$drawn_graphs{queriesbyuser_graph}
| User | Request type | Count | Duration |
|---|
Duration by user
Key values
- $main_user_duration[1] ($main_user_duration[0]) Main time consuming user
$drawn_graphs{durationbyuser_graph}
| User | Request type | Count | Duration |
|---|
Queries by host
Key values
- $main_host[0] Main host
- $main_host[1] Requests
- $main_host_duration[1] ($main_host_duration[0])
- Main time consuming host
$drawn_graphs{queriesbyhost_graph}
| Host | Request type | Count | Duration |
|---|
Most frequent waiting queries (N)
| Rank | Count | Total time | Min time | Max time | Avg duration | Query |
|---|---|---|---|---|---|---|
| $rank | $count | $total_time | $min_time | $max_time | $avg_time |
$query $md5
$example
" . $normalyzed_info{$k}{samples}{$d}{plan} . "\n";
}
print $fh qq{
$details$explain }; $idx++; } print $fh qq{ |
| $NODATA | ||||||
Queries that waited the most
| Rank | Wait time | Query |
|---|---|---|
| $rank | $time |
$query $md5
$details |
| $NODATA | ||
Queries generating the most temporary files (N)
| Rank | Count | Total size | Min size | Max size | Avg size | Query |
|---|---|---|---|---|---|---|
| $rank | $count | $total_size | $min_size | $max_size | $avg_size |
$query $md5
$example
$details}; $idx++ } print $fh qq{ |
Queries generating the largest temporary files
| Rank | Size | Query |
|---|---|---|
| $rank | $size |
$query $md5
$details |
Queries generating the most cancellation (N)
| Rank | Count | Query |
|---|---|---|
| $rank | $count |
$query $md5
$example
"; $details .= "Database: $normalyzed_info{$k}{samples}{$d}{db} " if ($normalyzed_info{$k}{samples}{$d}{db}); $details .= "User: $normalyzed_info{$k}{samples}{$d}{user} " if ($normalyzed_info{$k}{samples}{$d}{user}); $details .= "Remote: $normalyzed_info{$k}{samples}{$d}{remote} " if ($normalyzed_info{$k}{samples}{$d}{remote}); $details .= "Application: $normalyzed_info{$k}{samples}{$d}{app} " if ($normalyzed_info{$k}{samples}{$d}{app}); $details .= "Bind query: yes " if ($normalyzed_info{$k}{samples}{$d}{bind}); print $fh qq{ $details}; $idx++ } print $fh qq{ |
Queries most cancelled
| Rank | Number | Query |
|---|---|---|
| $rank | $count |
$query $md5
$details |
Top Queries
Histogram of query times
Key values
- $most_range_value $most_range duration
$drawn_graphs{histogram_query_times_graph}
| Range | Count | Percentage |
|---|
Slowest individual queries
| Rank | Duration | Query |
|---|---|---|
| $rank | $duration |
$query $md5
$details$explain |
| $NODATA | ||
Time consuming queries
| Rank | Total duration | Times executed | Min duration | Max duration | Avg duration | Query | |||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| $zday | $h | " . &comma_numbers($normalyzed_info{$k}{chronos}{$d}{$h}{count}) . " | " . &convert_time($normalyzed_info{$k}{chronos}{$d}{$h}{duration}) . " | " . &convert_time($normalyzed_info{$k}{chronos}{$d}{$h}{average}) . " | |||||||
| $zday | $h:$rd | " . &comma_numbers($hourly_count{"$h:$rd"}) . " | " . &convert_time($hourly_duration{"$h:$rd"}) . " | " . &convert_time($hourly_duration{"$h:$rd"}/($hourly_count{"$h:$rd"}||1)) . " | |||||||
| $rank | $duration | $count | $min | $max | $avg |
$query $md5
Times Reported Time consuming queries #$rank$query_histo
$users_involved $apps_involved }; if (scalar keys %{$normalyzed_info{$k}{users}} > 0) { print $fh qq{
$details}; $idx++; } } print $fh qq{
$details}; $idx++; } } print $fh qq{
" . $normalyzed_info{$k}{samples}{$d}{plan} . "\n";
}
$query = &highlight_code($normalyzed_info{$k}{samples}{$d}{query});
my $md5 = '';
$md5 = 'md5: ' . md5_hex($normalyzed_info{$k}{samples}{$d}{query}) if ($enable_checksum);
print $fh qq{
$details$explain }; $idx++; } print $fh qq{ |
|||||
| $NODATA | |||||||||||
Most frequent queries (N)
| Rank | Times executed | Total duration | Min duration | Max duration | Avg duration | Query | |||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| $zday | $h | " . &comma_numbers($normalyzed_info{$k}{chronos}{$d}{$h}{count}) . " | " . &convert_time($normalyzed_info{$k}{chronos}{$d}{$h}{duration}) . " | " . &convert_time($normalyzed_info{$k}{chronos}{$d}{$h}{average}) . " | |||||||
| $zday | $h:$rd | " . &comma_numbers($hourly_count{"$h:$rd"}) . " | " . &convert_time($hourly_duration{"$h:$rd"}) . " | " . &convert_time($hourly_duration{"$h:$rd"}/($hourly_count{"$h:$rd"}||1)) . " | |||||||
| $rank | $count | $duration | $min | $max | $avg |
$query $md5
Times Reported Time consuming queries #$rank$query_histo
$users_involved $apps_involved }; if (scalar keys %{$normalyzed_info{$k}{users}} > 0) { print $fh qq{
$details}; $idx++; } } print $fh qq{
$details}; $idx++; } } print $fh qq{
" . $normalyzed_info{$k}{samples}{$d}{plan} . "";
}
$query = &highlight_code($normalyzed_info{$k}{samples}{$d}{query});
my $md5 = '';
$md5 = 'md5: ' . md5_hex($normalyzed_info{$k}{samples}{$d}{query}) if ($enable_checksum);
print $fh qq{
$details$explain }; $idx++; } print $fh qq{ |
|||||
| $NODATA | |||||||||||
Normalized slowest queries (N)
| Rank | Min duration | Max duration | Avg duration | Times executed | Total duration | Query | |||||
|---|---|---|---|---|---|---|---|---|---|---|---|
| $zday | $h | " . &comma_numbers($normalyzed_info{$k}{chronos}{$d}{$h}{count}) . " | " . &convert_time($normalyzed_info{$k}{chronos}{$d}{$h}{duration}) . " | " . &convert_time($normalyzed_info{$k}{chronos}{$d}{$h}{average}) . " | |||||||
| $zday | $h:$rd | " . &comma_numbers($hourly_count{"$h:$rd"}) . " | " . &convert_time($hourly_duration{"$h:$rd"}) . " | " . &convert_time($hourly_duration{"$h:$rd"}/($hourly_count{"$h:$rd"}||1)) . " | |||||||
| $rank | $min | $max | $avg | $count | $duration |
$query $md5
Times Reported Time consuming queries #$rank$query_histo
$users_involved }; if (scalar keys %{$normalyzed_info{$k}{users}} > 0) { print $fh qq{
$details}; $idx++; } } print $fh qq{
$details}; $idx++; } } print $fh qq{
" . $normalyzed_info{$k}{samples}{$d}{plan} . "\n";
}
$query = &highlight_code($normalyzed_info{$k}{samples}{$d}{query});
my $md5 = '';
$md5 = 'md5: ' . md5_hex($normalyzed_info{$k}{samples}{$d}{query}) if ($enable_checksum);
print $fh qq{
$details$explain }; $idx++; } print $fh qq{ |
|||||
| $NODATA | |||||||||||
Connections
}; # Draw connections information &print_established_connection() if (!$disable_hourly); # Show per database/user connections &print_database_connection(); # Show per user connections &print_user_connection(); # Show per client ip connections &print_host_connection(); } # Show session per database statistics if (!$disable_session && !$pgbouncer_only) { print $fh qq{Sessions
}; # Show number of simultaneous sessions &print_simultaneous_session(); # Show histogram for session times &print_histogram_session_times(); # Show per database sessions &print_database_session(); # Show per user sessions &print_user_session(); # Show per host sessions &print_host_session(); # Show per application sessions &print_app_session(); } # Display checkpoint and temporary files report if (!$disable_checkpoint && !$pgbouncer_only) { print $fh qq{pgBouncer
}; # Draw pgbouncer own statistics &print_pgbouncer_stats() if (!$disable_hourly); # Draw connections information &print_established_pgb_connection() if (!$disable_hourly); # Show per database/user connections &print_database_pgb_connection(); # Show per user connections &print_user_pgb_connection(); # Show per client ip connections &print_host_pgb_connection(); # Show number of simultaneous sessions &print_simultaneous_pgb_session(); # Show histogram for session times &print_histogram_pgb_session_times(); # Show per database sessions &print_database_pgb_session(); # Show per user sessions &print_user_pgb_session(); # Show per host sessions &print_host_pgb_session(); # Show most used reserved pool &show_pgb_reserved_pool(); # Show Most Frequent Errors/Events &show_pgb_error_as_html(); } } # Show errors report if (!$disable_error) { if (!$error_only) { print $fh qq{Events
Log levels
Key values
- $total_logs Log entries
$drawn_graphs{logstype_graph}
| Type | Count | Percentage |
|---|
Events distribution
Key values
- $max_events{PANIC} PANIC entries
- $max_events{FATAL} FATAL entries
- $max_events{ERROR} ERROR entries
- $max_events{WARNING} WARNING entries
$drawn_graphs{'eventspersecond_graph'}
Error class distribution
Key values
- $total_logs Errors count
- $most_present most present error class
$drawn_graphs{errorclass_graph}
| Class | Code | Count | Percentage |
|---|
Most Frequent Errors/Events
Key values
- $main_error Max number of times the same event was reported
- $total Total events found
| Rank | Times reported | Error | ||||
|---|---|---|---|---|---|---|
| $zday | $h | " . &comma_numbers($error_info{$k}{chronos}{$d}{$h}{count}) . " | ||||
| $zday | $h:$rd | " . &comma_numbers($hourly_count{"$h:$rd"}) . " | ||||
| $rank | $count |
$msg Times Reported Most Frequent Error / Event #$rank$error_histo
"; } if ($error_info{$k}{context}[$i]) { $info .= "Context: " . &escape_html($error_info{$k}{context}[$i]) . " "; } if ($error_info{$k}{hint}[$i]) { $info .= "Hint: " . &escape_html($error_info{$k}{hint}[$i]) . " "; } if ($error_info{$k}{statement}[$i]) { $info .= "Statement: " . &escape_html($error_info{$k}{statement}[$i]) . " "; } if ($error_info{$k}{db}[$i]) { $details .= "Database: $error_info{$k}{db}[$i]\n"; $details .= "Application: $error_info{$k}{app}[$i]\n"; $details .= "User: $error_info{$k}{user}[$i]\n"; $details .= "Remote: $error_info{$k}{remote}[$i]\n"; $details .= "Code: $error_info{$k}{sqlstate}[$i]\n"; } $details =~ s/ $info $details}; } print $fh qq{ |
||||
| $NODATA | ||||||
Most Frequent Errors/Events
Key values
- $main_error Max number of times the same event was reported
- $total Total events found
| Rank | Times reported | Error | ||||
|---|---|---|---|---|---|---|
| $zday | $h | " . &comma_numbers($pgb_error_info{$k}{chronos}{$d}{$h}{count}) . " | ||||
| $zday | $h:$rd | " . &comma_numbers($hourly_count{"$h:$rd"}) . " | ||||
| $rank | $count |
$msg
Times Reported Most Frequent Error / Event #$rank$error_histo
"; } print $fh qq{ $details}; } print $fh qq{ |
||||
| $NODATA | ||||||
Most used reserved pools
Key values
- $main_pool Most used reserved pool
- $main_pool_val Time used
- $total Total time reserved pools was used
| Rank | Times used | Reserved pool | ||||
|---|---|---|---|---|---|---|
| $zday | $h | " . &comma_numbers($pgb_pool_info{$k}{chronos}{$d}{$h}{count}) . " | ||||
| $zday | $h:$rd | " . &comma_numbers($hourly_count{"$h:$rd"}) . " | ||||
| $rank | $count |
$k
Times Reported Most used reserved pools #$rank$pool_histo
|
||||
| $NODATA | ||||||
$title
NO DATASET
$title
NO DATASET
NO DATASET
NO DATASET
| "; map { $str .= ' | ' . $day_lbl{$_} . ' | '; } @wday; $str .= "$d | "; } else { $currow[$wd] = "$d | "; } if ($wd == 6) { $week = sprintf("%02d", $wn); if (-e "$outdir/$year/week-$week/index.html") { $week = "$week | "; } else { $week = "$week | "; } map { $_ = "" if ($_ eq ''); } @currow; $str .= " |
|---|---|
| $week | "; } else { $week = "$week | "; } map { $_ = "" if ($_ eq ''); } @currow; $str .= " |
$month_name{$month}
$str
| t |
","
"]},aS=A(l),j=aS.appendChild(l.createElement("div"));T.optgroup=T.option;T.tbody=T.tfoot=T.colgroup=T.caption=T.thead;T.th=T.td;bJ.fn.extend({text:function(e){return bJ.access(this,function(b3){return b3===aG?bJ.text(this):this.empty().append((this[0]&&this[0].ownerDocument||l).createTextNode(b3))},null,e,arguments.length)},wrapAll:function(e){if(bJ.isFunction(e)){return this.each(function(b4){bJ(this).wrapAll(e.call(this,b4))})}if(this[0]){var b3=bJ(e,this[0].ownerDocument).eq(0).clone(true);if(this[0].parentNode){b3.insertBefore(this[0])}b3.map(function(){var b4=this;while(b4.firstChild&&b4.firstChild.nodeType===1){b4=b4.firstChild}return b4}).append(this)}return this},wrapInner:function(e){if(bJ.isFunction(e)){return this.each(function(b3){bJ(this).wrapInner(e.call(this,b3))})}return this.each(function(){var b3=bJ(this),b4=b3.contents();if(b4.length){b4.wrapAll(e)}else{b3.append(e)}})},wrap:function(e){var b3=bJ.isFunction(e);return this.each(function(b4){bJ(this).wrapAll(b3?e.call(this,b4):e)})},unwrap:function(){return this.parent().each(function(){if(!bJ.nodeName(this,"body")){bJ(this).replaceWith(this.childNodes)}}).end()},append:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1||this.nodeType===11||this.nodeType===9){this.appendChild(e)}})},prepend:function(){return this.domManip(arguments,true,function(e){if(this.nodeType===1||this.nodeType===11||this.nodeType===9){this.insertBefore(e,this.firstChild)}})},before:function(){return this.domManip(arguments,false,function(e){if(this.parentNode){this.parentNode.insertBefore(e,this)}})},after:function(){return this.domManip(arguments,false,function(e){if(this.parentNode){this.parentNode.insertBefore(e,this.nextSibling)}})},remove:function(e,b5){var b4,b3=0;for(;(b4=this[b3])!=null;b3++){if(!e||bJ.filter(e,[b4]).length>0){if(!b5&&b4.nodeType===1){bJ.cleanData(k(b4))}if(b4.parentNode){if(b5&&bJ.contains(b4.ownerDocument,b4)){bs(k(b4,"script"))}b4.parentNode.removeChild(b4)}}}return this},empty:function(){var b3,e=0;for(;(b3=this[e])!=null;e++){if(b3.nodeType===1){bJ.cleanData(k(b3,false))}while(b3.firstChild){b3.removeChild(b3.firstChild)}if(b3.options&&bJ.nodeName(b3,"select")){b3.options.length=0}}return this},clone:function(b3,e){b3=b3==null?false:b3;e=e==null?b3:e;return this.map(function(){return bJ.clone(this,b3,e)})},html:function(e){return bJ.access(this,function(b6){var b5=this[0]||{},b4=0,b3=this.length;if(b6===aG){return b5.nodeType===1?b5.innerHTML.replace(aA,""):aG}if(typeof b6==="string"&&!al.test(b6)&&(bJ.support.htmlSerialize||!J.test(b6))&&(bJ.support.leadingWhitespace||!b2.test(b6))&&!T[(m.exec(b6)||["",""])[1].toLowerCase()]){b6=b6.replace(aD,"<$1>");try{for(;b4| ');G.appendTo(E);G.data("seriesIndex",s);if(this.escapeHtml){G.text(D)}else{G.html(D)}E=null;G=null}return this._elem}})(jQuery); WRFILE: jqplot.pointLabels.min.js (function(c){c.jqplot.PointLabels=function(e){this.show=c.jqplot.config.enablePlugins;this.location="n";this.labelsFromSeries=false;this.seriesLabelIndex=null;this.labels=[];this._labels=[];this.stackedValue=false;this.ypadding=6;this.xpadding=6;this.escapeHTML=true;this.edgeTolerance=-5;this.formatter=c.jqplot.DefaultTickFormatter;this.formatString="";this.hideZeros=false;this._elems=[];c.extend(true,this,e)};var a=["nw","n","ne","e","se","s","sw","w"];var d={nw:0,n:1,ne:2,e:3,se:4,s:5,sw:6,w:7};var b=["se","s","sw","w","nw","n","ne","e"];c.jqplot.PointLabels.init=function(j,h,f,g,i){var e=c.extend(true,{},f,g);e.pointLabels=e.pointLabels||{};if(this.renderer.constructor===c.jqplot.BarRenderer&&this.barDirection==="horizontal"&&!e.pointLabels.location){e.pointLabels.location="e"}this.plugins.pointLabels=new c.jqplot.PointLabels(e.pointLabels);this.plugins.pointLabels.setLabels.call(this)};c.jqplot.PointLabels.prototype.setLabels=function(){var f=this.plugins.pointLabels;var h;if(f.seriesLabelIndex!=null){h=f.seriesLabelIndex}else{if(this.renderer.constructor===c.jqplot.BarRenderer&&this.barDirection==="horizontal"){h=(this._plotData[0].length<3)?0:this._plotData[0].length-1}else{h=(this._plotData.length===0)?0:this._plotData[0].length-1}}f._labels=[];if(f.labels.length===0||f.labelsFromSeries){if(f.stackedValue){if(this._plotData.length&&this._plotData[0].length){for(var e=0;e | |
| '+
' '+
''+
' | ').appendTo(tr);
var td = $(''); td.appendTo(tr); td.data('seriesIndex', idx); if (this.escapeHtml) { td.text(label); } else { td.html(label); } tr = null; td = null; } return this._elem; }; })(jQuery); pgbadger-9.2/resources/jqplot.dateAxisRenderer.js 0000664 0000000 0000000 00000073206 13136621702 0022261 0 ustar 00root root 0000000 0000000 /** * jqPlot * Pure JavaScript plotting plugin using jQuery * * Version: 1.0.8 * Revision: 1250 * * Copyright (c) 2009-2013 Chris Leonello * jqPlot is currently available for use in all personal or commercial projects * under both the MIT (http://www.opensource.org/licenses/mit-license.php) and GPL * version 2.0 (http://www.gnu.org/licenses/gpl-2.0.html) licenses. This means that you can * choose the license that best suits your project and use it accordingly. * * Although not required, the author would appreciate an email letting him * know of any substantial use of jqPlot. You can reach the author at: * chris at jqplot dot com or see http://www.jqplot.com/info.php . * * If you are feeling kind and generous, consider supporting the project by * making a donation at: http://www.jqplot.com/donate.php . * * sprintf functions contained in jqplot.sprintf.js by Ash Searle: * * version 2007.04.27 * author Ash Searle * http://hexmen.com/blog/2007/03/printf-sprintf/ * http://hexmen.com/js/sprintf.js * The author (Ash Searle) has placed this code in the public domain: * "This code is unrestricted: you are free to use it however you like." * */ (function($) { /** * Class: $.jqplot.DateAxisRenderer * A plugin for a jqPlot to render an axis as a series of date values. * This renderer has no options beyond those supplied by the |
| hi: | %s |
| low: | %s |
| close: | %s |
' + label + '
').insertBefore(plot.eventCanvas._elem);
if (this.dataLabelCenterOn) {
x -= labelelem.width()/2;
y -= labelelem.height()/2;
}
else {
x -= labelelem.width() * Math.sin(avgang/2);
y -= labelelem.height()/2;
}
x = Math.round(x);
y = Math.round(y);
labelelem.css({left: x, top: y});
}
}
};
$.jqplot.PieAxisRenderer = function() {
$.jqplot.LinearAxisRenderer.call(this);
};
$.jqplot.PieAxisRenderer.prototype = new $.jqplot.LinearAxisRenderer();
$.jqplot.PieAxisRenderer.prototype.constructor = $.jqplot.PieAxisRenderer;
// There are no traditional axes on a pie chart. We just need to provide
// dummy objects with properties so the plot will render.
// called with scope of axis object.
$.jqplot.PieAxisRenderer.prototype.init = function(options){
//
this.tickRenderer = $.jqplot.PieTickRenderer;
$.extend(true, this, options);
// I don't think I'm going to need _dataBounds here.
// have to go Axis scaling in a way to fit chart onto plot area
// and provide u2p and p2u functionality for mouse cursor, etc.
// for convienence set _dataBounds to 0 and 100 and
// set min/max to 0 and 100.
this._dataBounds = {min:0, max:100};
this.min = 0;
this.max = 100;
this.showTicks = false;
this.ticks = [];
this.showMark = false;
this.show = false;
};
$.jqplot.PieLegendRenderer = function(){
$.jqplot.TableLegendRenderer.call(this);
};
$.jqplot.PieLegendRenderer.prototype = new $.jqplot.TableLegendRenderer();
$.jqplot.PieLegendRenderer.prototype.constructor = $.jqplot.PieLegendRenderer;
/**
* Class: $.jqplot.PieLegendRenderer
* Legend Renderer specific to pie plots. Set by default
* when user creates a pie plot.
*/
$.jqplot.PieLegendRenderer.prototype.init = function(options) {
// Group: Properties
//
// prop: numberRows
// Maximum number of rows in the legend. 0 or null for unlimited.
this.numberRows = null;
// prop: numberColumns
// Maximum number of columns in the legend. 0 or null for unlimited.
this.numberColumns = null;
$.extend(true, this, options);
};
// called with context of legend
$.jqplot.PieLegendRenderer.prototype.draw = function() {
var legend = this;
if (this.show) {
var series = this._series;
this._elem = $(document.createElement('table'));
this._elem.addClass('jqplot-table-legend');
var ss = {position:'absolute'};
if (this.background) {
ss['background'] = this.background;
}
if (this.border) {
ss['border'] = this.border;
}
if (this.fontSize) {
ss['fontSize'] = this.fontSize;
}
if (this.fontFamily) {
ss['fontFamily'] = this.fontFamily;
}
if (this.textColor) {
ss['textColor'] = this.textColor;
}
if (this.marginTop != null) {
ss['marginTop'] = this.marginTop;
}
if (this.marginBottom != null) {
ss['marginBottom'] = this.marginBottom;
}
if (this.marginLeft != null) {
ss['marginLeft'] = this.marginLeft;
}
if (this.marginRight != null) {
ss['marginRight'] = this.marginRight;
}
this._elem.css(ss);
// Pie charts legends don't go by number of series, but by number of data points
// in the series. Refactor things here for that.
var pad = false,
reverse = false,
nr,
nc;
var s = series[0];
var colorGenerator = new $.jqplot.ColorGenerator(s.seriesColors);
if (s.show) {
var pd = s.data;
if (this.numberRows) {
nr = this.numberRows;
if (!this.numberColumns){
nc = Math.ceil(pd.length/nr);
}
else{
nc = this.numberColumns;
}
}
else if (this.numberColumns) {
nc = this.numberColumns;
nr = Math.ceil(pd.length/this.numberColumns);
}
else {
nr = pd.length;
nc = 1;
}
var i, j;
var tr, td1, td2;
var lt, rs, color;
var idx = 0;
var div0, div1;
for (i=0; i