diff options
Diffstat (limited to 'src/pmdas/oracle/pmdaoracle.pl')
| -rw-r--r-- | src/pmdas/oracle/pmdaoracle.pl | 2364 |
1 files changed, 2364 insertions, 0 deletions
diff --git a/src/pmdas/oracle/pmdaoracle.pl b/src/pmdas/oracle/pmdaoracle.pl new file mode 100644 index 0000000..b45be2f --- /dev/null +++ b/src/pmdas/oracle/pmdaoracle.pl @@ -0,0 +1,2364 @@ +# +# Copyright (c) 2012 Red Hat. +# Copyright (c) 2009,2012 Aconex. All Rights Reserved. +# Copyright (c) 1998 Silicon Graphics, Inc. All Rights Reserved. +# +# This program is free software; you can redistribute it and/or modify it +# under the terms of the GNU General Public License as published by the +# Free Software Foundation; either version 2 of the License, or (at your +# option) any later version. +# +# This program is distributed in the hope that it will be useful, but +# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY +# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. +# + +use strict; +use warnings; +use PCP::PMDA; +use DBI; + +my $username = 'SYSTEM'; +my $password = 'manager'; +my @sids = ( 'master' ); + +# Configuration files for overriding the above settings +for my $file ( '/etc/pcpdbi.conf', # system defaults (lowest priority) + pmda_config('PCP_PMDAS_DIR') . '/oracle/oracle.conf', + pmda_config('PCP_VAR_DIR') . '/config/oracle/oracle.conf', + './oracle.conf' ) { # current directory (high priority) + eval `cat $file` unless ! -f $file; +} + +use vars qw( $pmda %sid_instances ); +use vars qw( %latch_instances %file_instances %rollback_instances ); +use vars qw( %reqdist_instances %rowcache_instances %session_instances ); +use vars qw( %object_cache_instances %system_event_instances ); +use vars qw( %librarycache_instances %waitstat_instances ); + +my $latch_indom = 0; +my $file_indom = 1; +my $rollback_indom = 2; +my $reqdist_indom = 3; +my $rowcache_indom = 4; +my $session_indom = 5; +my $object_cache_indom = 6; +my $system_event_indom = 7; +my $librarycache_indom = 8; +my $waitstat_indom = 9; +my $sid_indom = 10; + +my @novalues = (); +my %object_cache_instances = ( + 'INDEX' => \@novalues, 'TABLE' => \@novalues, + 'CLUSTER' => \@novalues, 'VIEW' => \@novalues, + 'SET' => \@novalues, 'SYNONYM' => \@novalues, + 'SEQUENCE' => \@novalues, 'PROCEDURE' => \@novalues, + 'FUNCTION' => \@novalues, 'PACKAGE' => \@novalues, + 'PACKAGE_BODY' => \@novalues, 'TRIGGER' => \@novalues, + 'CLASS' => \@novalues, 'OBJECT' => \@novalues, + 'USER' => \@novalues, 'DBLINK' => \@novalues, + 'NON-EXISTENT' => \@novalues, 'NOT_LOADED' => \@novalues, + 'OTHER' => \@novalues ); + +my %sids_by_name; +my %tables_by_name = ( + 'sysstat' => { + insts_handle => undef, fetch_handle => undef, values => {}, + # insts => SID indom is a static array + fetch => 'SELECT statistic#, value FROM v$sysstat' }, + 'license' => { + insts_handle => undef, fetch_handle => undef, values => {}, }, + 'latch' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT latch#, name FROM v$latch', + fetch => 'SELECT latch#, name FROM v$latch' }, + 'filestat' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT file#, name FROM v$datafile', + fetch => 'SELECT file#, phyrds, phywrts, phyblkrd,' . + ' phyblkwrt, readtim, writetim' . + ' FROM v$filestat' }, + 'rollstat' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT usn, name FROM v$rollname', + fetch => 'SELECT usn, rssize, writes, xacts, gets, waits, hwmsize,' . + ' shrinks, wraps, extends, aveshrink, aveactive' . + ' FROM v$rollstat' }, + 'reqdist' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT bucket FROM v$reqdist', + fetch => 'SELECT bucket, count FROM v$reqdist' }, + 'backup' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT file# FROM v$backup', + fetch => 'SELECT file#, status FROM v$backup' }, + 'rowcache' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT cache#, subordinate#, parameter FROM v$rowcache', + fetch => 'SELECT cache#, subordinate#, count, gets, getmisses,' . + ' scans, scanmisses' . + ' FROM v$rowcache' }, + 'sesstat' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT sid FROM v$session', + fetch => 'SELECT sid, statistic#, value FROM v$sesstat' }, + 'object_cache' => { + insts_handle => undef, fetch_handle => undef, values => {}, + # insts => object_cache indom is a static array + fetch => 'SELECT type, sharable_mem, loads, locks, pins' . + ' FROM v$db_object_cache' }, + 'system_event' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT event#,name FROM v$event_name', + fetch => 'SELECT event_id, event, total_waits, total_timeouts,' . + ' time_waited, average_wait' . + ' FROM v$system_event' }, + 'version' => { + insts_handle => undef, fetch_handle => undef, values => {}, + fetch => 'SELECT DISTINCT banner INTO :pc_version' . + ' FROM v$version WHERE banner LIKE \'Oracle%\'' }, + 'librarycache' => { + insts_handle => undef, fetch_handle => undef, values => {}, + insts => 'SELECT namespace FROM v$librarycache', + fetch => 'SELECT namespace, gets, gethits, gethitratio, pins,' . + ' pinhits, pinhitratio, reloads, invalidations' . + ' FROM v$librarycache' }, +); + +my %tables_by_cluster = ( + '0' => { + name => 'sysstat', + setup => \&setup_sysstat, + indom => $sid_indom, + values => \&sysstat_values }, + '1' => { + name => 'license', + setup => \&setup_license, + indom => $sid_indom, + values => \&license_values }, + '2' => { + name => 'latch', + setup => \&setup_latch, + indom => $latch_indom, + values => \&latch_values }, + '3' => { + name => 'filestat', + setup => \&setup_filestat, + indom => $file_indom, + values => \&filestat_values }, + '4' => { + name => 'rollstat', + setup => \&setup_rollstat, + indom => $rollback_indom, + values => \&rollstat_values }, + '5' => { + name => 'reqdist', + setup => \&setup_reqdist, + indom => $reqdist_indom, + values => \&reqdist_values }, + '6' => { + name => 'backup', + setup => \&setup_backup, + indom => 'backup', + values => \&backup_values }, + '7' => { + name => 'rowcache', + setup => \&setup_rowcache, + indom => $rowcache_indom, + values => \&rowcache_values }, +# '8' => { +# name => 'sesstat', +# setup => \&setup_sesstat, +# indom => $session_indom, +# values => \&sesstat_values }, + '9' => { + name => 'object_cache', + setup => \&setup_object_cache, + indom => $object_cache_indom, + values => \&object_cache_values }, + '10' => { + name => 'system_event', + setup => \&setup_system_event, + indom => $system_event_indom, + insts => \&system_event_insts, + values => \&system_event_values }, + '11' => { + name => 'version', + setup => \&setup_version, + indom => $sid_indom, + values => \&version_values }, + '12' => { + name => 'librarycache', + setup => \&setup_librarycache, + indom => $librarycache_indom, + values => \&librarycache_values }, + '13' => { + name => 'waitstat', + setup => \&setup_waitstat, + indom => $waitstat_indom, + values => \&waitstat_values }, +); + +sub oracle_connection_setup +{ + foreach my $sid (@sids) { + my $db = $sids_by_name{$sid}{db_handle}; + $db = oracle_sid_connection_setup($sid, $db); + $sids_by_name{$sid}{db_handle} = $db; + } +} + +sub oracle_sid_connection_setup +{ + my $sid = shift; + my $dbh = shift; + + if (!defined($dbh)) { + $dbh = DBI->connect("dbi:Oracle:$sid", $username, $password); + if (defined($dbh)) { + $pmda->log("Oracle connection established\n"); + + foreach my $key (keys %tables_by_name) { + my ( $query, $insts_query, $fetch_query ); + + $insts_query = $tables_by_name{$key}{insts}; + $fetch_query = $tables_by_name{$key}{fetch}; + + if (defined($insts_query)) { + $query = $dbh->prepare($fetch_query); + $tables_by_name{$key}{insts_handle} = $query + unless (!defined($query)); + } + if (defined($fetch_query)) { + $query = $dbh->prepare($fetch_query); + $tables_by_name{$key}{fetch_handle} = $query + unless (!defined($query)); + } + } + } + } + return $dbh; +} + +sub oracle_refresh +{ + my ($cluster) = @_; + + foreach my $sid (@sids) { + my $db = $sids_by_name{$sid}{db_handle}; + my $name = $tables_by_cluster{"$cluster"}{name}; + my $refresh = $tables_by_cluster{"$cluster"}{values}; + &$refresh($db, $sid, $tables_by_name{$name}{fetch_handle}); + } +} + +sub oracle_fetch_callback +{ + my ( $cluster, $item, $inst) = @_; + my $metric_name = pmda_pmid_name($cluster, $item); + my ( $indom, $table, $value, $valueref, @columns ); + + return (PM_ERR_PMID, 0) unless defined($metric_name); + $table = $metric_name; + $table =~ s/^oracle\.//; + $table =~ s/\.*$//; + + # $pmda->log("fetch_cb $metric_name $cluster:$item ($inst) - $table\n"); + $indom = $tables_by_cluster{"$cluster"}{indom}; + $valueref = pmda_inst_lookup($indom, $inst); + return (PM_ERR_INST, 0) unless defined($valueref); + @columns = @$valueref; + $value = $columns[$item]; + return (PM_ERR_APPVERSION, 0) unless defined($value); + + return ($value, 1); +} + +# +# Refresh routines - one per table (cluster) - format database query +# result set for later use by the generic fetch callback routine. +# +sub refresh_results +{ + my ( $dbh, $handle ) = @_; + + return undef + unless (defined($dbh) && defined($handle) && defined($handle->execute())); + return $handle->fetchall_arrayref(); +} + +sub system_event_values +{ + my ( $dbh, $sid, $handle ) = @_; + my $result = refresh_results($dbh, $handle); + + %system_event_instances = (); # refresh indom too + if (defined($result)) { + for my $i (0 .. $#{$result}) { # for each row (instance) returned + my $eventid = $result->[$i][0]; + my $eventname = $result->[$i][1]; + my $instname = "$sid/$eventid $eventname"; + my @values = @$result[$i]; + $system_event_instances{$instname} = \@values; + } + } + $pmda->replace_indom($system_event_indom, \%system_event_instances); +} + +sub system_event_insts +{ + my ( $dbh, $sid, $handle ) = @_; + my $result = refresh_results($dbh, $handle); + + %system_event_instances = (); + if (defined($result)) { + for my $i (0 .. $#{$result}) { # for each row (instance) returned + my $eventid = $result->[$i][0]; + my $eventname = $result->[$i][1]; + my $instname = "$sid/$eventid $eventname"; + $system_event_instances{$instname} = \@novalues; + } + } + $pmda->replace_indom($system_event_indom, \%system_event_instances); +} + +sub license_values { } +sub license_insts { } + + + +sub oracle_indoms_setup +{ + $pmda->add_indom($latch_indom, \%latch_instances, + 'Instance domain "latch" from Oracle PMDA', +'The latches used by the RDBMS. The latch instance domain does not +change. Latches are simple, low-level serialization mechanisms which +protect access to structures in the system global area (SGA).'); + + $pmda->add_indom($file_indom, \%file_instances, + 'Instance domain "file" from Oracle PMDA', +'The collection of data files that make up the database. This instance +domain may change during database operation as files are added to or +removed.'); + + $pmda->add_indom($rollback_indom, \%rollback_instances, + 'Instance domain "rollback" from Oracle PMDA', +'The collection of rollback segments for the database. This instance +domain may change during database operation as segments are added to or +removed.'); + + $pmda->add_indom($reqdist_indom, \%reqdist_instances, + 'RDBMS Request Distribution from Oracle PMDA', +'Each instance is one of the buckets in the histogram of RDBMS request +service times. The instances are named according to the longest +service time that will be inserted into its bucket. The instance +domain does not change.'); + + $pmda->add_indom($rowcache_indom, \%rowcache_instances, + 'Instance domain "rowcache" from Oracle PMDA', +'Each instance is a type of data dictionary cache. The names are +derived from the database parameters that define the number of entries +in the particular cache. In some cases subordinate caches exist. +Names for such sub-caches are composed of the subordinate cache +parameter name prefixed with parent cache name with a "." as a +separator. Each cache has an identifying number which appears in +parentheses after the textual portion of the cache name to resolve +naming ambiguities. The rowcache instance domain does not change.'); + + $pmda->add_indom($session_indom, \%session_instances, + 'Instance domain "session" from Oracle PMDA', +'Each instance is a session to the Oracle database. Sessions may come +and go rapidly. The instance names correspond to the numeric Oracle +session identifiers.'); + + $pmda->add_indom($object_cache_indom, \%object_cache_instances, + 'Instance domain "cache objects" from Oracle PMDA', +'The various types of objects in the database object cache. This +includes such objects as indices, tables, procedures, packages, users +and dblink. Any object types not recognized by the Oracle PMDA are +grouped together into a special instance named "other". The instance +domain may change as various types of objects are bought into and +flushed out of the database object cache.'); + + $pmda->add_indom($system_event_indom, \%system_event_instances, + 'Instance domain "system events" from Oracle PMDA', +'The various system events which the database may wait on. This +includes events such as interprocess communication, control file I/O, +log file I/O, timers.'); + + $pmda->add_indom($librarycache_indom, \%librarycache_instances, + 'Instance domain "librarycache" from Oracle PMDA', ''); + $pmda->add_indom($waitstat_indom, \%waitstat_instances, + 'Instance domain "wait statistics" from Oracle PMDA', ''); + + $pmda->add_indom($sid_indom, \%sid_instances, + 'Instance domain "SID" from Oracle PMDA', +'The system identifiers used by the RDBMS and monitored by this PMDA.'); +} + +sub oracle_metrics_setup +{ + foreach my $cluster (sort (keys %tables_by_cluster)) { + my $setup = $tables_by_cluster{"$cluster"}{setup}; + my $indom = $tables_by_cluster{"$cluster"}{indom}; + &$setup($cluster, $indom, $tables_by_cluster{"$cluster"}{params}); + } +} + +# +# Setup routines - one per cluster, add metrics to PMDA +# + +sub setup_waitstat # block contention stats from v$waitstat +{ + $pmda->add_metric(pmda_pmid(13,0), PM_TYPE_U32, $waitstat_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.waitstat.count', + 'Number of waits for each block class', +'The number of waits for each class of block. This value is obtained +from the COUNT column of the V$WAITSTAT view.'); + + $pmda->add_metric(pmda_pmid(13,1), PM_TYPE_U32, $waitstat_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.waitstat.time', + 'Sum of all wait times for each block class', +'The sum of all wait times for each block class. This value is obtained +from the TIME column of the V$WAITSTAT view.'); +} + +sub setup_version # version data from the v$version view +{ + $pmda->add_metric(pmda_pmid(11,0), PM_TYPE_STRING, $sid_indom, + PM_SEM_DISCRETE, pmda_units(0,0,0,0,0,0), + 'oracle.version', + 'Oracle component name and version number', ''); +} + +sub setup_system_event # statistics from v$system_event +{ + $pmda->add_metric(pmda_pmid(10,0), PM_TYPE_U32, $system_event_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.event.waits', + 'Number of waits for various system events', +'The total number of waits for various system events. This value is +obtained from the TOTAL_WAITS column of the V$SYSTEM_EVENT view.'); + + $pmda->add_metric(pmda_pmid(10,1), PM_TYPE_U32, $system_event_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.event.timeouts', + 'Number of timeouts for various system events', +'The total number of timeouts for various system events. This value is +obtained from the TOTAL_TIMEOUTS column of the V$SYSTEM_EVENT view.'); + + $pmda->add_metric(pmda_pmid(10,2), PM_TYPE_U32, $system_event_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.event.time_waited', + 'Total time waited for various system events', +'The total amount of time waited for various system events. This value +is obtained from the TIME_WAITED column of the V$SYSTEM_EVENT view and +converted to units of milliseconds.'); + + $pmda->add_metric(pmda_pmid(10,3), PM_TYPE_FLOAT, $system_event_indom, + PM_SEM_INSTANT, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.event.average_wait', + 'Average time waited for various system events', +'The average time waited for various system events. This value is +obtained from the AVERAGE_WAIT column of the V$SYSTEM_EVENT view +and converted to units of milliseconds.'); +} + +sub setup_sysstat ## statistics from v$sysstat +{ + $pmda->add_metric(pmda_pmid(0,0), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.logons', 'Total cumulative logons', +'The "logons cumulative" statistic from the V$SYSSTAT view. This is the +total number of logons since the instance started.'); + + $pmda->add_metric(pmda_pmid(0,1), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.curlogons', 'Total current logons', +'The "logons current" statistic from the V$SYSSTAT view. This is the +total number of current logons.'); + + $pmda->add_metric(pmda_pmid(0,2), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.opencursors', 'Total cumulative opened cursors', +'The "opened cursors cumulative" statistic from the V$SYSSTAT view. +This is the total number of cursors opened since the instance started.'); + + $pmda->add_metric(pmda_pmid(0,3), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.current_cursors', 'Total current open cursors', +'The "opened cursors current" statistic from the V$SYSSTAT view. This +is the total number of current open cursors.'); + + $pmda->add_metric(pmda_pmid(0,4), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.user_commits', 'Total user commits', +'The "user commits" statistic from the V$SYSSTAT view. When a user +commits a transaction, the redo generated that reflects the changes +made to database blocks must be written to disk. Commits often +represent the closest thing to a user transaction rate.'); + + $pmda->add_metric(pmda_pmid(0,5), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.user_rollbacks', 'Total user rollbacks', +'The "user rollbacks" statistic from the V$SYSSTAT view. This statistic +stores the number of times users manually issue the ROLLBACK statement +or an error occurs during users\' transactions.'); + + $pmda->add_metric(pmda_pmid(0,6), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.user_calls', 'Total user calls', +'The "user calls" statistic from the V$SYSSTAT view. Oracle allocates +resources (Call State Objects) to keep track of relevant user call data +structures every time you log in, parse or execute. When determining +activity, the ratio of user calls to RPI calls, gives you an indication +of how much internal work gets generated as a result of the type of +requests the user is sending to Oracle.'); + + $pmda->add_metric(pmda_pmid(0,7), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.recursecalls', 'Total recursive calls', +'The "recursive calls" statistic from the V$SYSSTAT view. Oracle +maintains tables used for internal processing. When Oracle needs to +make a change to these tables, it internally generates an SQL +statement. These internal SQL statements generate recursive calls.'); + + $pmda->add_metric(pmda_pmid(0,8), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.recursecpu', 'Total recursive cpu usage', +'The "recursive cpu usage" statistic from the V$SYSSTAT view. The total +CPU time used by non-user calls (recursive calls). Subtract this value +from oracle.sysstat.sessioncpu to determine how much CPU time was used +by the user calls. Units are milliseconds of CPU time.'); + + $pmda->add_metric(pmda_pmid(0,9), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.session.lreads', 'Total session logical reads', +'The "session logical reads" statistic from the V$SYSSTAT view. This +statistic is basically the sum of oracle.systat.dbbgets and +oracle.sysstat.consgets. Refer to the help text for these +individual metrics for more information.'); + + $pmda->add_metric(pmda_pmid(0,10), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.session.procspace', +'Total session stored procedure space', +'The "session stored procedure space" statistic from the V$SYSSTAT +view. This metric shows the amount of memory that this session is +using for stored procedures.'); + + $pmda->add_metric(pmda_pmid(0,11), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.cpucall', 'CPU used when call started', +'The "CPU used when call started" statistic from the V$SYSSTAT view. +This is the session CPU when current call started. Units are +milliseconds of CPU time.'); + + $pmda->add_metric(pmda_pmid(0,12), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.session.cpu', 'Total CPU used by this session', +'The "CPU used by this session" statistic from the V$SYSSTAT view. This +is the amount of CPU time used by a session between when a user call +started and ended. Units for the exported metric are milliseconds, but +Oracle uses an internal resolution of tens of milliseconds and some +user calls can complete within 10 milliseconds, resulting in the start +and end user-call times being the same. In this case, zero +milliseconds are added to the statistic.'); + + $pmda->add_metric(pmda_pmid(0,13), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_SEC,0), + 'oracle.sysstat.session.contime', 'Session connect time', +'The "session connect time" statistic from the V$SYSSTAT view. +Wall clock time of when session logon occured. Units are seconds +since the epoch.'); + + $pmda->add_metric(pmda_pmid(0,14), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,1,0,0,PM_TIME_SEC,0), + 'oracle.sysstat.procidle', 'Total process last non-idle time', +'The "process last non-idle time" statistic from the V$SYSSTAT view. +This is the last time this process was not idle. Units are seconds +since the epoch.'); + + $pmda->add_metric(pmda_pmid(0,15), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.session.mem', 'Session UGA memory', +'The "session UGA memory" statistic from the V$SYSSTAT view. This +shows the current session UGA (User Global Area) memory size.'); + + $pmda->add_metric(pmda_pmid(0,16), PM_TYPE_U32, $sid_indom, + PM_SEM_DISCRETE, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.session.maxmem', 'Maximum session UGA memory', +'The "session UGA memory max" statistic from the V$SYSSTAT view. This +shows the maximum session UGA (User Global Area) memory size.'); + + $pmda->add_metric(pmda_pmid(0,17), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.msgxmit', 'Total messages sent', +'The "messages sent" statistic from the V$SYSSTAT view. This is the +total number of messages sent between Oracle processes. A message is +sent when one Oracle process wants to post another to perform some +action.'); + + $pmda->add_metric(pmda_pmid(0,18), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.msgrecv', 'Total messages received', +'The "messages received" statistic from the V$SYSSTAT view. This is the +total number of messages received. A message is sent when one Oracle +process wants to post another to perform some action.'); + + $pmda->add_metric(pmda_pmid(0,19), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.bgtimeouts', 'Total background timeouts', +'The "background timeouts" statistic from the V$SYSSTAT view. This is +a count of the times where a background process has set an alarm for +itself and the alarm has timed out rather than the background process +being posted by another process to do some work.'); + + $pmda->add_metric(pmda_pmid(0,20), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.sepgamem', 'Session PGA memory', +'The "session PGA memory" statistic from the V$SYSSTAT view. This +shows the current session PGA (Process Global Area) memory size.'); + + $pmda->add_metric(pmda_pmid(0,21), PM_TYPE_U32, $sid_indom, + PM_SEM_DISCRETE, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.session.maxpgamem', 'Maximum session PGA memory', +'The "session PGA memory max" statistic from the V$SYSSTAT view. This +shows the maximum session PGA (Process Global Area) memory size.'); + + $pmda->add_metric(pmda_pmid(0,22), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.enqueue.timeouts', 'Total enqueue timeouts', +'The "enqueue timeouts" statistic from the V$SYSSTAT view. This is +the total number of enqueue operations (get and convert) that timed +out before they could complete.'); + + $pmda->add_metric(pmda_pmid(0,23), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.enqueue.waits', 'Total enqueue waits', +'The "enqueue waits" statistic from the V$SYSSTAT view. This is the +total number of waits that happened during an enqueue convert or get +because the enqueue could not be immediately granted.'); + + $pmda->add_metric(pmda_pmid(0,24), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.enqueue.deadlocks', 'Total enqueue deadlocks', +'The "enqueue deadlocks" statistic from the V$SYSSTAT view. This is +the total number of enqueue deadlocks between different sessions.'); + + $pmda->add_metric(pmda_pmid(0,25), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.enqueue.requests', 'Total enqueue requests', +'The "enqueue requests" statistic from the V$SYSSTAT view. This is +the total number of enqueue gets.'); + + $pmda->add_metric(pmda_pmid(0,26), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.enqueue.conversions', 'Total enqueue conversions', +'The "enqueue conversions" statistic from the V$SYSSTAT view. This is +the total number of enqueue converts.'); + + $pmda->add_metric(pmda_pmid(0,27), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.enqueue.releases', 'Total enqueue releases', +'The "enqueue releases" statistic from the V$SYSSTAT view. This is +the total number of enqueue releases.'); + + $pmda->add_metric(pmda_pmid(0,28), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globlock.gets', 'Total global lock gets (sync)', +'The "global lock gets (sync)" statistic from the V$SYSSTAT view. This +is the total number of synchronous global lock gets.'); + + $pmda->add_metric(pmda_pmid(0,29), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globlock.agets', 'Total global lock gets (async)', +'The "global lock gets (async)" statistic from the V$SYSSTAT view. +This is the total number of asynchronous global lock gets.'); + + $pmda->add_metric(pmda_pmid(0,30), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.globlock.gettime', 'Total global lock get time', +'The "global lock get time" statistic from the V$SYSSTAT view. This is +the total elapsed time of all synchronous global lock gets.'); + + $pmda->add_metric(pmda_pmid(0,31), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globlock.cvts', 'Total global lock converts (sync)', +'The "global lock converts (sync)" statistic from the V$SYSSTAT view. +This is the total number of synchronous global lock converts.'); + + $pmda->add_metric(pmda_pmid(0,32), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globlock.acvts', 'Total global lock converts (async)', +'The "global lock converts (async)" statistic from the V$SYSSTAT view. +This is the total number of asynchronous global lock converts.'); + + $pmda->add_metric(pmda_pmid(0,33), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.globlock.cvttime', 'Total global lock convert time', +'The "global lock convert time" statistic from the V$SYSSTAT view. +This is the total elapsed time of all synchronous global lock converts.'); + + $pmda->add_metric(pmda_pmid(0,34), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globlock.rels', 'Total global lock releases (sync)', +'The "global lock releases (sync)" statistic from the V$SYSSTAT view. +This is the total number of synchronous global lock releases.'); + + $pmda->add_metric(pmda_pmid(0,35), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globlock.arels', 'Total global lock releases (async)', +'The "global lock releases (async)" statistic from the V$SYSSTAT view. +This is the total number of asynchronous global lock releases.'); + + $pmda->add_metric(pmda_pmid(0,36), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.globlock.reltime', 'Total global lock release time', +'The "global lock release time" statistic from the V$SYSSTAT view. +This is the elapsed time of all synchronous global lock releases.'); + + $pmda->add_metric(pmda_pmid(0,37), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbbgets', 'Total db block gets', +'The "db block gets" statistic from the V$SYSSTAT view. This tracks +the number of blocks obtained in CURRENT mode.'); + + $pmda->add_metric(pmda_pmid(0,38), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.consgets', 'Total consistent gets', +'The "consistent gets" statistic from the V$SYSSTAT view. This is the +number of times a consistent read was requested for a block. Also see +the help text for oracle.sysstat.conschanges.'); + + $pmda->add_metric(pmda_pmid(0,39), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.preads', 'Total physical reads', +'The "physical reads" statistic from the V$SYSSTAT view. This is the +number of I/O requests to the operating system to retrieve a database +block from the disk subsystem. This is a buffer cache miss. +Logical reads = oracle.sysstat.consgets + oracle.sysstat.dbbgets. +Logical reads and physical reads are used to calculate the buffer hit +ratio.'); + + $pmda->add_metric(pmda_pmid(0,40), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.pwrites', 'Total physical writes', +'The "physical writes" statistic from the V$SYSSTAT view. This is the +number of I/O requests to the operating system to write a database +block to the disk subsystem. The bulk of the writes are performed +either by DBWR or LGWR.'); + + $pmda->add_metric(pmda_pmid(0,41), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.wreqs', 'Total write requests', +'The "write requests" statistic from the V$SYSSTAT view. This is the +number of times DBWR has flushed sets of dirty buffers to disk.'); + + $pmda->add_metric(pmda_pmid(0,42), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,0,0,0,0), + 'oracle.sysstat.dirtyqlen', 'Total summed dirty queue length', +'The "summed dirty queue length" statistic from the V$SYSSTAT view. +This is the sum of the dirty LRU queue length after every write +request. +Divide by the write requests (oracle.sysstat.wreqs) to get the +average queue length after write completion. For more information see +the help text associated with oracle.sysstat.wreqs.'); + + $pmda->add_metric(pmda_pmid(0,43), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbbchanges', 'Total db block changes', +'The "db block changes" statistic from the V$SYSSTAT view. This metric +is closely related to "consistent changes" +(oracle.sysstat.conschanges) and counts the total number of +changes made to all blocks in the SGA that were part of an update or +delete operation. These are the changes that are generating redo log +entries and hence will be permanent changes to the database if the +transaction is committed. +This metric is a rough indication of total database work and indicates +(possibly on a per-transaction level) the rate at which buffers are +being dirtied.'); + + $pmda->add_metric(pmda_pmid(0,44), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.chwrtime', 'Total change write time', +'The "change write time" statistic from the V$SYSSTAT view. This is +the elapsed time for redo write for changes made to CURRENT blocks.'); + + $pmda->add_metric(pmda_pmid(0,45), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.conschanges', 'Total consistent changes', +'The "consistent changes" statistic from the V$SYSSTAT view. This is +the number of times a database block has applied rollback entries to +perform a consistent read on the block.'); + + $pmda->add_metric(pmda_pmid(0,46), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.syncwr', 'Total redo sync writes', +'The "redo sync writes" statistic from the V$SYSSTAT view. Usually, +redo that is generated and copied into the log buffer need not be +flushed out to disk immediately. The log buffer is a circular buffer +that LGWR periodically flushes. This metric is incremented when +changes being applied must be written out to disk due to commit.'); + + $pmda->add_metric(pmda_pmid(0,47), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.redo.synctime', 'Total redo sync time', +'The "redo sync time" statistic from the V$SYSSTAT view. This is the +elapsed time of all redo sync writes (oracle.sysstat.redo.syncwr).'); + +$pmda->add_metric(pmda_pmid(0,48), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.exdeadlocks', 'Total exchange deadlocks', +'The "exchange deadlocks" statistic from the V$SYSSTAT view. This is +the number of times that a process detected a potential deadlock when +exchanging two buffers and raised an internal, restartable error. +Index scans are currently the only operations which perform exchanges.'); + +$pmda->add_metric(pmda_pmid(0,49), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.buffer.freereqs', 'Total free buffer requested', +'The "free buffer requested" statistic from the V$SYSSTAT view. This is +the number of times a reusable buffer or a free buffer was requested to +create or load a block.'); + + $pmda->add_metric(pmda_pmid(0,50), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.buffer.dirtyinsp', 'Total dirty buffers inspected', +'The "dirty buffers inspected" statistic from the V$SYSSTAT view. +This is the number of dirty buffers found by the foreground while +the foreground is looking for a buffer to reuse.'); + + $pmda->add_metric(pmda_pmid(0,51), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.buffer.freeinsp', 'Total free buffer inspected', +'The "free buffer inspected" statistic from the V$SYSSTAT view. This is +the number of buffers skipped over from the end of an LRU queue in +order to find a reusable buffer. The difference between this metric +and the oracle.sysstat.buffer.dirtyinsp metric is the number of +buffers that could not be used because they were either busy, needed to +be written after rapid aging out, or they have a user, a waiter, or are +being read/written. Refer to the oracle.sysstat.buffer.dirtyinsp +help text also.'); + + $pmda->add_metric(pmda_pmid(0,52), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.timeouts', 'Total DBWR timeouts', +'The "DBWR timeouts" statistic from the V$SYSSTAT view. This is the +number of times that the DBWR has been idle since the last timeout. +These are the times that the DBWR looked for buffers to idle write.'); + + $pmda->add_metric(pmda_pmid(0,53), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.mkfreereqs', 'Total DBWR make free requests', +'The "DBWR make free requests" statistic from the V$SYSSTAT view. +This is the number of messages received requesting DBWR to make +some more free buffers for the LRU.'); + + $pmda->add_metric(pmda_pmid(0,54), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.freebuffnd', 'Total DBWR free buffers found', +'The "DBWR free buffers found" statistic from the V$SYSSTAT view. +This is the number of buffers that DBWR found to be clean when it +was requested to make free buffers. Divide this by +oracle.sysstat.dbwr.mkfreereqs to find the average number of +reusable buffers at the end of each LRU.'); + + $pmda->add_metric(pmda_pmid(0,55), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.lruscans', 'Total DBWR lru scans', +'The "DBWR lru scans" statistic from the V$SYSSTAT view. This is the +number of times that DBWR does a scan of the LRU queue looking for +buffers to write. This includes times when the scan is to fill a batch +being written for another purpose such as a checkpoint. This metric\'s +value is always greater than oracle.sysstat.dbwr.mkfreereqs.'); + + $pmda->add_metric(pmda_pmid(0,56), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.sumscandepth', 'Total DBWR summed scan depth', +'The "DBWR summed scan depth" statistic from the V$SYSSTAT view. The +current scan depth (number of buffers scanned by DBWR) is added to this +metric every time DBWR scans the LRU for dirty buffers. Divide by +oracle.sysstat.dbwr.lruscans to find the average scan depth.'); + + $pmda->add_metric(pmda_pmid(0,57), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.bufsscanned', 'Total DBWR buffers scanned', +'The "DBWR buffers scanned" statistic from the V$SYSSTAT view. +This is the total number of buffers looked at when scanning each +LRU set for dirty buffers to clean. This count includes both dirty +and clean buffers. Divide by oracle.sysstat.dbwr.lruscans to +find the average number of buffers scanned.'); + + $pmda->add_metric(pmda_pmid(0,58), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.checkpoints', 'Total DBWR checkpoints', +'The "DBWR checkpoints" statistic from the V$SYSSTAT view. +This is the number of times the DBWR was asked to scan the cache +and write all blocks marked for a checkpoint.'); + + $pmda->add_metric(pmda_pmid(0,59), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.xinstwrites', 'Total DBWR cross instance writes', +'The "DBWR cross instance writes" statistic from the V$SYSSTAT view. +This is the total number of blocks written for other instances so that +they can access the buffers.'); + + $pmda->add_metric(pmda_pmid(0,60), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.remote.instundowr', + 'Total remote instance undo writes', +'The "remote instance undo writes" statistic from the V$SYSSTAT view. +This is the number of times this instance performed a dirty undo write +so that another instance could read that data.'); + + $pmda->add_metric(pmda_pmid(0,61), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.remote.instundoreq', + 'Total remote instance undo requests', +'The "remote instance undo requests" statistic from the V$SYSSTAT view. +This is the number of times this instance requested undo from another +instance so it could be read CR.'); + + $pmda->add_metric(pmda_pmid(0,62), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.xinstcrrd', 'Total cross instance CR read', +'The "cross instance CR read" statistic from the V$SYSSTAT view. This +is the number of times this instance made a cross instance call to +write a particular block due to timeout on an instance lock get. The +call allowed the blocks to be read CR rather than CURRENT.'); + + $pmda->add_metric(pmda_pmid(0,63), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmg.cscalls', 'Total calls to kcmgcs', +'The "calls to kcmgcs" statistic from the V$SYSSTAT view. This is the +total number of calls to get the current System Commit Number (SCN).'); + +$pmda->add_metric(pmda_pmid(0,64), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmg.rscalls', 'Total calls to kcmgrs', +'The "calls to kcmgrs" statistic from the V$SYSSTAT view. This is the +total number of calls to get a recent System Commit Number (SCN).'); + + $pmda->add_metric(pmda_pmid(0,65), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmg.ascalls', 'Total calls to kcmgas', +'The "calls to kcmgas" statistic from the V$SYSSTAT view. This is the +total number of calls that Get and Advance the System Commit Number +(SCN). Also used when getting a Batch of SCN numbers.'); + + $pmda->add_metric(pmda_pmid(0,66), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.nodlmscnsgets', + 'Total next scns gotten without going to DLM', +'The "next scns gotten without going to DLM" statistic from the +V$SYSSTAT view. This is the number of SCNs (System Commit Numbers) +obtained without going to the DLM (Distributed Lock Manager).'); + + $pmda->add_metric(pmda_pmid(0,67), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.entries', 'Total redo entries', +'The "redo entries" statistic from the V$SYSSTAT view. This metric +is incremented each time redo entries are copied into the redo log +buffer.'); + + $pmda->add_metric(pmda_pmid(0,68), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.redo.size', 'Total redo size', +'The "redo size" statistic from the V$SYSSTAT view. +This is the number of bytes of redo generated.'); + + $pmda->add_metric(pmda_pmid(0,69), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.entslin', 'Total redo entries linearized', +'The "redo entries linearized" statistic from the V$SYSSTAT view. This +is the number of entries of size <= REDO_ENTRY_PREBUILD_THRESHOLD. +Building these entries increases CPU time but may increase concurrency.'); + + $pmda->add_metric(pmda_pmid(0,70), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.bufallret', + 'Total redo buffer allocation retries', +'The "redo buffer allocation retries" statistic from the V$SYSSTAT +view. This is the total number of retries necessary to allocate space +in the redo buffer. Retries are needed because either the redo writer +has gotten behind, or because an event (such as log switch) is +occuring.'); + + $pmda->add_metric(pmda_pmid(0,71), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.smallcpys', 'Total redo small copies', +'The "redo small copies" statistic from the V$SYSSTAT view. This is the +total number of entries where size <= LOG_SMALL_ENTRY_MAX_SIZE. These +entries are copied using the protection of the allocation latch, +eliminating the overhead of getting the copy latch. This is generally +only useful for multi-processor systems.'); + + $pmda->add_metric(pmda_pmid(0,72), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.redo.wastage', 'Total redo wastage', +'The "redo wastage" statistic from the V$SYSSTAT view. This is the +number of bytes wasted because redo blocks needed to be written before +they are completely full. Early writing may be needed to commit +transactions, to be able to write a database buffer or to switch logs.'); + + $pmda->add_metric(pmda_pmid(0,73), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.redo.wrlatchtime', 'Total redo writer latching time', +'The "redo writer latching time" statistic from the V$SYSSTAT view. +This is the elapsed time needed by LGWR to obtain and release each copy +latch. This is only used if the LOG_SIMULTANEOUS_COPIES initialization +parameter is greater than zero.'); + + $pmda->add_metric(pmda_pmid(0,74), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.writes', 'Total redo writes', +'The "redo writes" statistic from the V$SYSSTAT view. +This is the total number of writes by LGWR to the redo log files.'); + + $pmda->add_metric(pmda_pmid(0,75), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.bwrites', 'Total redo blocks written', +'The "redo blocks written" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,76), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.redo.wrtime', 'Total redo write time', +'The "redo write time" statistic from the V$SYSSTAT view. This is the +total elapsed time of the write from the redo log buffer to the current +redo log file.'); + + $pmda->add_metric(pmda_pmid(0,77), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.logspreqs', 'Total redo log space requests', +'The "redo log space requests" statistic from the V$SYSSTAT view. The +active log file is full and Oracle is waiting for disk space to be +allocated for the redo log entries. Space is created by performing a +log switch. +Small log files in relation to the size of the SGA or the commit rate +of the work load can cause problems. When the log switch occurs, +Oracle must ensure that all committed dirty buffers are written to disk +before switching to a new log file. If you have a large SGA full of +dirty buffers and small redo log files, a log switch must wait for DBWR +to write dirty buffers to disk before continuing.'); + + $pmda->add_metric(pmda_pmid(0,78), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.redo.logspwaittime', 'Total redo log space wait time', +'The "redo log space wait time" statistic from the V$SYSSTAT view. This +is the total elapsed time spent waiting for redo log space requests +(refer to the oracle.sysstat.redo.logspreqs metric).'); + + $pmda->add_metric(pmda_pmid(0,79), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.logswintrs', 'Total redo log switch interrupts', +'The "redo log switch interrupts" statistic from the V$SYSSTAT view. +This is the number of times that another instance asked this instance +to advance to the next log file.'); + + $pmda->add_metric(pmda_pmid(0,80), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.redo.ordermarks', 'Total redo ordering marks', +'The "redo ordering marks" statistic from the V$SYSSTAT view. This is +the number of times that an SCN (System Commit Number) had to be +allocated to force a redo record to have a higher SCN than a record +generated in another thread using the same block.'); + + $pmda->add_metric(pmda_pmid(0,81), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.hashlwgets', 'Total hash latch wait gets', +'The "hash latch wait gets" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,82), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.bgchkpts.started', + 'Total background checkpoints started', +'The "background checkpoints started" statistic from the V$SYSSTAT +view. This is the number of checkpoints started by the background. It +can be larger than the number completed if a new checkpoint overrides +an incomplete checkpoint. This only includes checkpoints of the +thread, not individual file checkpoints for operations such as offline +or begin backup. This statistic does not include the checkpoints +performed in the foreground, such as ALTER SYSTEM CHECKPOINT LOCAL.'); + + $pmda->add_metric(pmda_pmid(0,83), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.bgchkpts.completed', + 'Total background checkpoints completed', +'The "background checkpoints completed" statistic from the V$SYSSTAT +view. This is the number of checkpoints completed by the background. +This statistic is incremented when the background successfully advances +the thread checkpoint.'); + + $pmda->add_metric(pmda_pmid(0,84), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.tranlock.fgreqs', + 'Total transaction lock foreground requests', +'The "transaction lock foreground requests" statistic from the V$SYSSTAT +view. For parallel server this is incremented on each call to ktugil() +"Kernel Transaction Get Instance Lock". For single instance this has +no meaning.'); + + $pmda->add_metric(pmda_pmid(0,85), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.tranlock.fgwaittime', + 'Total transaction lock foreground wait time', +'The "transaction lock foreground wait time" statistic from the +V$SYSSTAT view. This is the total time spent waiting for a transaction +instance lock.'); + + $pmda->add_metric(pmda_pmid(0,86), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.tranlock.bggets', + 'Total transaction lock background gets', +'The "transaction lock background gets" statistic from the V$SYSSTAT +view. For parallel server this is incremented on each call to ktuglb() +"Kernel Transaction Get lock in Background".'); + + $pmda->add_metric(pmda_pmid(0,87), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.tranlock.bggettime', + 'Total transaction lock background get time', +'The "transaction lock background get time" statistic from the V$SYSSTAT +view. Total time spent waiting for a transaction instance lock in +Background.'); + + $pmda->add_metric(pmda_pmid(0,88), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.shortscans', 'Total table scans (short tables)', +'The "table scans (short tables)" statistic from the V$SYSSTAT view. +Long (or conversely short) tables can be defined by optimizer hints +coming down into the row source access layer of Oracle. The table must +have the CACHE option set.'); + + $pmda->add_metric(pmda_pmid(0,89), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.longscans', 'Total table scans (long tables)', +'The "table scans (long tables)" statistic from the V$SYSSTAT view. +Long (or conversely short) tables can be defined as tables that do not +meet the short table criteria described in the help text for the +oracle.sysstat.table.shortscans metric.'); + + $pmda->add_metric(pmda_pmid(0,90), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.scanrows', 'Total table scan rows gotten', +'The "table scan rows gotten" statistic from the V$SYSSTAT view. This +is collected during a scan operation, but instead of counting the +number of database blocks (see oracle.sysstat.table.scanblocks), +it counts the rows being processed.'); + + $pmda->add_metric(pmda_pmid(0,91), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.scanblocks', 'Total table scan blocks gotten', +'The "table scan blocks gotten" statistic from the V$SYSSTAT view. +During scanning operations, each row is retrieved sequentially by +Oracle. This metric is incremented for each block encountered during +the scan. +This informs you of the number of database blocks that you had to get +from the buffer cache for the purpose of scanning. Compare the value +of this parameter to the value of oracle.sysstat.consgets +(consistent gets) to get a feel for how much of the consistent read +activity can be attributed to scanning.'); + + $pmda->add_metric(pmda_pmid(0,92), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.rowidfetches', 'Total table fetch by rowid', +'The "table fetch by rowid" statistic from the V$SYSSTAT view. When +rows are fetched using a ROWID (usually from an index), each row +returned increments this counter. +This metric is an indication of row fetch operations being performed +with the aid of an index. Because doing table scans usually indicates +either non-optimal queries or tables without indices, this metric +should increase as the above issues have been addressed in the +application.'); + + $pmda->add_metric(pmda_pmid(0,93), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.contfetches', 'Total table fetch continued row', +'The "table fetch continued row" statistic from the V$SYSSTAT view. +This metric is incremented when a row that spans more than one block is +encountered during a fetch. +Retrieving rows that span more than one block increases the logical I/O +by a factor that corresponds to the number of blocks that need to be +accessed. Exporting and re-importing may eliminate this problem. Also +take a closer look at the STORAGE parameters PCT_FREE and PCT_USED. +This problem cannot be fixed if rows are larger than database blocks +(for example, if the LONG datatype is used and the rows are extremely +large).'); + + $pmda->add_metric(pmda_pmid(0,94), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.clustkey.scans', 'Total cluster key scans', +'The "cluster key scans" statistic from the V$SYSSTAT view. +This is the number of cluster scans that were started.'); + + $pmda->add_metric(pmda_pmid(0,95), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.clustkey.scanblocks', + 'Total cluster key scan block gets', +'The "cluster key scan block gets" statistic from the V$SYSSTAT view. +This is the number of blocks obtained in a cluster scan.'); + + $pmda->add_metric(pmda_pmid(0,96), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.sql.parsecpu', 'Total parse time cpu', +'The "parse time cpu" statistic from the V$SYSSTAT view. This is the +total CPU time used for parsing (hard and soft parsing). Units are +milliseconds of CPU time.'); + + $pmda->add_metric(pmda_pmid(0,97), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.sql.parsereal', 'Total parse time elapsed', +'The "parse time elapsed" statistic from the V$SYSSTAT view. +This is the total elapsed time for parsing. Subtracting +oracle.sysstat.sql.parsecpu from this metric gives the total +waiting time for parse resources. Units are milliseconds.'); + + $pmda->add_metric(pmda_pmid(0,98), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sql.parsed', 'Total parse count', +'The "parse count (total)" statistic from the V$SYSSTAT view. This is +the total number of parse calls (hard and soft). A soft parse is a +check to make sure that the permissions on the underlying objects have +not changed.'); + + $pmda->add_metric(pmda_pmid(0,99), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sql.executed', 'Total execute count', +'The "execute count" statistic from the V$SYSSTAT view. +This is the total number of calls (user and recursive) that +execute SQL statements.'); + + $pmda->add_metric(pmda_pmid(0,100), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sql.memsorts', 'Total sorts (memory)', +'The "sorts (memory)" statistic from the V$SYSSTAT view. If the number +of disk writes is zero, then the sort was performed completely in +memory and this metric is incremented. +This is more an indication of sorting activity in the application +workload. You cannot do much better than memory sorts, except for no +sorts at all. Sorting is usually caused by selection criteria +specifications within table join SQL operations.'); + + $pmda->add_metric(pmda_pmid(0,101), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sql.disksorts', 'Total sorts (disk)', +'The "sorts (disk)" statistic from the V$SYSSTAT view. If the number +of disk writes is non-zero for a given sort operation, then this metric +is incremented. +Sorts that require I/O to disk are quite resource intensive. +Try increasing the size of the Oracle initialization parameter +SORT_AREA_SIZE.'); + + $pmda->add_metric(pmda_pmid(0,102), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sql.rowsorts', 'Total sorts (rows)', +'The "sorts (rows)" statistic from the V$SYSSTAT view. +This is the total number of rows sorted.'); + + $pmda->add_metric(pmda_pmid(0,103), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sccachehits', 'Total session cursor cache hits', +'The "session cursor cache hits" statistic from the V$SYSSTAT view. +This is the count of the number of hits in the session cursor cache. +A hit means that the SQL statement did not have to be reparsed. +By subtracting this metric from oracle.sysstat.sql.parsed one can +determine the real number of parses that have been performed.'); + + $pmda->add_metric(pmda_pmid(0,104), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cursauths', 'Total cursor authentications', +'The "cursor authentications" statistic from the V$SYSSTAT view. This +is the total number of cursor authentications. The number of times +that cursor privileges have been verified, either for a SELECT or +because privileges were revoked from an object, causing all users of +the cursor to be re-authenticated.'); + + $pmda->add_metric(pmda_pmid(0,105), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.recovery.breads', 'Total recovery blocks read', +'The "recovery blocks read" statistic from the V$SYSSTAT view. +This is the number of blocks read during recovery.'); + + $pmda->add_metric(pmda_pmid(0,106), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.recovery.areads', 'Total recovery array reads', +'The "recovery array reads" statistic from the V$SYSSTAT view. This is +the number of reads performed during recovery.'); + + $pmda->add_metric(pmda_pmid(0,107), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.recovery.areadtime', 'Total recovery array read time', +'The "recovery array read time" statistic from the V$SYSSTAT view. +This is the elapsed time of I/O while doing recovery.'); + + $pmda->add_metric(pmda_pmid(0,108), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.rowidrngscans', + 'Total table scans (rowid ranges)', +'The "table scans (rowid ranges)" statistic from the V$SYSSTAT view. +This is a count of the table scans with specified ROWID endpoints. +These scans are performed for Parallel Query.'); + + $pmda->add_metric(pmda_pmid(0,109), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.cachepartscans', + 'Total table scans (cache partitions)', +'The "table scans (cache partitions)" statistic from the V$SYSSTAT +view. This is a count of range scans on tables that have the CACHE +option enabled.'); + + $pmda->add_metric(pmda_pmid(0,110), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cr.createblk', 'Total CR blocks created', +'The "CR blocks created" statistic from the V$SYSSTAT view. +A buffer in the buffer cache was cloned. The most common reason +for cloning is that the buffer is held in an incompatible mode.'); + + $pmda->add_metric(pmda_pmid(0,111), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cr.convcurrblk', + 'Total Current blocks converted for CR', +'The "Current blocks converted for CR" statistic from the V$SYSSTAT +view. A CURRENT buffer (shared or exclusive) is made CR before it can +be used.'); + + $pmda->add_metric(pmda_pmid(0,112), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.unnecprocclnscn', + 'Total Unnecessary process cleanup for SCN batching', +'The "Unnecessary process cleanup for SCN batching" statistic from the +V$SYSSTAT view. This is the total number of times that the process +cleanup was performed unnecessarily because the session/process did not +get the next batched SCN (System Commit Number). The next batched SCN +went to another session instead.'); + + $pmda->add_metric(pmda_pmid(0,113), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.consread.transtable.undo', + 'Total transaction tables consistent reads - undo records applied', +'The "transaction tables consistent reads - undo records applied" +statistic from the V$SYSSTAT view. This is the number of UNDO records +applied to get CR images of data blocks.'); + + $pmda->add_metric(pmda_pmid(0,114), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.consread.transtable.rollback', + 'Total transaction tables consistent read rollbacks', +'The "transaction tables consistent read rollbacks" statistic from the +V$SYSSTAT view. This is the total number of times transaction tables +are CR rolled back.'); + + $pmda->add_metric(pmda_pmid(0,115), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.datablkundo', + 'Total data blocks consistent reads - undo records applied', +'The "data blocks consistent reads - undo records applied" statistic +from the V$SYSSTAT view. This is the total number of UNDO records +applied to get CR images of data blocks.'); + + $pmda->add_metric(pmda_pmid(0,116), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.noworkgets', 'Total no work - consistent read gets', +'The "no work - consistent read gets" statistic from the V$SYSSTAT +view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,117), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.consread.cleangets', + 'Total cleanouts only - consistent read gets', +'The "cleanouts only - consistent read gets" statistic from the +V$SYSSTAT view. The number of times a CR get required a block +cleanout ONLY and no application of undo.'); + + $pmda->add_metric(pmda_pmid(0,118), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.consread.rollbackgets', + 'Total rollbacks only - consistent read gets', +'The "rollbacks only - consistent read gets" statistic from the +V$SYSSTAT view. This is the total number of CR operations requiring +UNDO to be applied but no block cleanout.'); + + $pmda->add_metric(pmda_pmid(0,119), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.consread.cleanrollbackgets', + 'Total cleanouts and rollbacks - consistent read gets', +'The "cleanouts and rollbacks - consistent read gets" statistic from the +V$SYSSTAT view. This is the total number of CR gets requiring BOTH +block cleanout and subsequent rollback to get to the required snapshot +time.'); + + $pmda->add_metric(pmda_pmid(0,120), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.rollbackchangeundo', + 'Total rollback changes - undo records applied', +'The "rollback changes - undo records applied" statistic from the +V$SYSSTAT view. This is the total number of undo records applied to +blocks to rollback real changes. Eg: as a result of a rollback command +and *NOT* in the process of getting a CR block image. +Eg: commit; + insert into mytab values (10); + insert into mytab values (20); + rollback; +should increase this statistic by 2 (assuming no recursive operations).'); + + $pmda->add_metric(pmda_pmid(0,121), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.transrollbacks', 'Total transaction rollbacks', +'The "transaction rollbacks" statistic from the V$SYSSTAT view. This is +the actual transaction rollbacks that involve undoing real changes. +Contrast with oracle.sysstat.user_rollbacks which only indicates the +number of ROLLBACK statements received.'); + + $pmda->add_metric(pmda_pmid(0,122), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cleanout.immedcurr', + 'Total immediate (CURRENT) block cleanout applications', +'The "immediate (CURRENT) block cleanout applications" statistic from +the V$SYSSTAT view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,123), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cleanout.immedcr', + 'Total immediate (CR) block cleanout applications', +'The "immediate (CR) block cleanout applications" statistic from the +V$SYSSTAT view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,124), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cleanout.defercurr', + 'Total deferred (CURRENT) block cleanout applications', +'The "deferred (CURRENT) block cleanout applications" statistic from +the V$SYSSTAT view. This is the number of times cleanout records are +deferred. Deferred changes are piggybacked with real changes.'); + + $pmda->add_metric(pmda_pmid(0,125), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.table.dirreadscans', 'Total table scans (direct read)', +'The "table scans (direct read)" statistic from the V$SYSSTAT view. +This is a count of table scans performed with direct read (bypassing +the buffer cache).'); + + $pmda->add_metric(pmda_pmid(0,126), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sccachecount', 'Total session cursor cache count', +'The "session cursor cache count" statistic from the V$SYSSTAT view. +This is the total number of cursors cached. This is only incremented +if SESSION_CACHED_CURSORS is greater than zero. This metric is the +most useful in V$SESSTAT. If the value for this statistic is close to +the setting of the initialization parameter SESSION_CACHED_CURSORS, the +value of the initialization parameter should be increased.'); + + $pmda->add_metric(pmda_pmid(0,127), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.totalfileopens', 'Total file opens', +'The "total file opens" statistic from the V$SYSSTAT view. This is the +total number of file opens being performed by the instance. Each +process needs a number of files (control file, log file, database file) +in order to work against the database.'); + + $pmda->add_metric(pmda_pmid(0,128), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cachereplaceopens', + 'Opens requiring cache replacement', +'The "opens requiring cache replacement" statistic from the V$SYSSTAT +view. This is the total number of file opens that caused a current +file to be closed in the process file cache.'); + + $pmda->add_metric(pmda_pmid(0,129), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.replacedfileopens', 'Opens of replaced files', +'The "opens of replaced files" statistic from the V$SYSSTAT view. This +is the total number of files that needed to be reopened because they +were no longer in the process file cache.'); + + $pmda->add_metric(pmda_pmid(0,130), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.total', 'Total commit cleanout calls', +'The "commit cleanouts" statistic from the V$SYSSTAT view. This is the +number of times that the cleanout block at commit time function was +performed.'); + + $pmda->add_metric(pmda_pmid(0,131), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.completed', + 'Successful commit cleanouts', +'The "commit cleanouts successfully completed" metric from the V$SYSSTAT +view. This is the number of times the cleanout block at commit time +function successfully completed.'); + + $pmda->add_metric(pmda_pmid(0,132), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.failures.writedisabled', + 'Commits when writes disabled', +'The "commit cleanout failures: write disabled" statistic from the +V$SYSSTAT view. This is the number of times that a cleanout at commit +time was performed but the writes to the database had been temporarily +disabled.'); + + $pmda->add_metric(pmda_pmid(0,133), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.failures.hotbackup', + 'Commit attempts during hot backup', +'The "commit cleanout failures: hot backup in progress" statistic +from the V$SYSSTAT view. This is the number of times that cleanout +at commit was attempted during hot backup.'); + + $pmda->add_metric(pmda_pmid(0,134), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.failures.bufferwrite', + 'Commits while buffer being written', +'The "commit cleanout failures: buffer being written" statistic from the +V$SYSSTAT view. This is the number of times that a cleanout at commit +time was attempted but the buffer was being written at the time.'); + + $pmda->add_metric(pmda_pmid(0,135), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.failures.callbackfail', + 'Commit callback fails', +'The "commit cleanout failures: callback failure" statistic from the +V$SYSSTAT view. This is the number of times that the cleanout callback +function returned FALSE (failed).'); + + $pmda->add_metric(pmda_pmid(0,136), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.failures.blocklost', + 'Commit fails due to lost block', +'The "commit cleanout failures: block lost" statistic from the V$SYSSTAT +view. This is the number of times that a cleanout at commit was +attempted but could not find the correct block due to forced write, +replacement, or switch CURRENT.'); + + $pmda->add_metric(pmda_pmid(0,137), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitcleanouts.failures.cannotpin', + 'Commit fails due to block pinning', +'The "commit cleanout failures: cannot pin" statistic from the V$SYSSTAT +view. This is the number of times that a commit cleanout was performed +but failed because the block could not be pinned.'); + + $pmda->add_metric(pmda_pmid(0,138), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.skiphotwrites', 'Total DBWR hot writes skipped', +'The "DBWR skip hot writes" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,139), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.ckptbufwrites', + 'Total DBWR checkpoint buffers written', +'The "DBWR checkpoint buffers written" statistic from the V$SYSSTAT +view. This is the number of times the DBWR was asked to scan the cache +and write all blocks marked for checkpoint.'); + + $pmda->add_metric(pmda_pmid(0,140), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.transwrites', + 'Total DBWR transaction table writes', +'The "DBWR transaction table writes" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,141), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.undoblockwrites', 'Total DBWR undo block writes', +'The "DBWR undo block writes" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,142), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.ckptwritereq', + 'Total DBWR checkpoint write requests', +'The "DBWR checkpoint write requests" statistic from the V$SYSSTAT +view. This is the number of times the DBWR was asked to scan the cache +and write all blocks.'); + + $pmda->add_metric(pmda_pmid(0,143), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.incrckptwritereq', + 'Total DBWR incr checkpoint write requests', +'The "DBWR incr. ckpt. write requests" statistic from the V$SYSSTAT +view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,144), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.revisitbuf', + 'Total DBWR being-written buffer revisits', +'The "DBWR revisited being-written buffer" statistic from the V$SYSSTAT +view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,145), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.xinstflushcalls', + 'Total DBWR cross instance flush calls', +'The "DBWR Flush object cross instance calls" statistic from the +V$SYSSTAT view. This is the number of times DBWR received a flush by +object number cross instance call (from a remote instance). This +includes both checkpoint and invalidate object.'); + + $pmda->add_metric(pmda_pmid(0,146), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.dbwr.nodirtybufs', + 'DBWR flush calls finding no dirty buffers', +'The "DBWR Flush object call found no dirty buffers" statistic from the +V$SYSSTAT view. DBWR didn\'t find any dirty buffers for an object that +was flushed from the cache.'); + + $pmda->add_metric(pmda_pmid(0,147), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.remote.instundoblockwr', + 'Remote instance undo block writes', +'The "remote instance undo block writes" statistic from the V$SYSSTAT +view. This is the number of times this instance wrote a dirty undo +block so that another instance could read it.'); + + $pmda->add_metric(pmda_pmid(0,148), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.remote.instundoheaderwr', + 'Remote instance undo header writes', +'The "remote instance undo header writes" statistic from the V$SYSSTAT +view. This is the number of times this instance wrote a dirty undo +header block so that another instance could read it.'); + + $pmda->add_metric(pmda_pmid(0,149), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmgss_snapshotscn', + 'Total calls to get snapshot SCN: kcmgss', +'The "calls to get snapshot scn: kcmgss" statistic from the V$SYSSTAT +view. This is the number of times a snap System Commit Number (SCN) +was allocated. The SCN is allocated at the start of a transaction.'); + + $pmda->add_metric(pmda_pmid(0,150), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmgss_batchwait', 'Total kcmgss waits for batching', +'The "kcmgss waited for batching" statistic from the V$SYSSTAT view. +This is the number of times the kernel waited on a snapshot System +Commit Number (SCN).'); + + $pmda->add_metric(pmda_pmid(0,151), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmgss_nodlmscnread', + 'Total kcmgss SCN reads with using DLM', +'The "kcmgss read scn without going to DLM" statistic from the V$SYSSTAT +view. This is the number of times the kernel casually confirmed the +System Commit Number (SCN) without using the Distributed Lock Manager +(DLM).'); + + $pmda->add_metric(pmda_pmid(0,152), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.kcmccs_currentscn', + 'Total kcmccs calls to get current SCN', +'The "kcmccs called get current scn" statistic from the V$SYSSTAT view. +This is the number of times the kernel got the CURRENT SCN (System +Commit Number) when there was a need to casually confirm the SCN.'); + + $pmda->add_metric(pmda_pmid(0,153), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.serializableaborts', 'Total serializable aborts', +'The "serializable aborts" statistic from the V$SYSSTAT view. This is +the number of times a SQL statement in serializable isolation level had +to abort.'); + + $pmda->add_metric(pmda_pmid(0,154), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globalcache.hashlatchwaits', + 'Global cache hash latch waits', +'The "global cache hash latch waits" statistic from the V$SYSSTAT view. +This is the number of times that the buffer cache hash chain latch +couldn\'t be acquired immediately, when processing a lock element.'); + + $pmda->add_metric(pmda_pmid(0,155), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globalcache.freelistwaits', + 'Global cache freelist waits', +'The "global cache freelist waits" statistic from the V$SYSSTAT view. +This is the number of pings for free lock elements (when all release +locks are in use).'); + + $pmda->add_metric(pmda_pmid(0,156), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.globalcache.defers', + 'Global cache ping request defers', +'The "global cache defers" statistic from the V$SYSSTAT view. +This is the number of times a ping request was deferred until later.'); + + $pmda->add_metric(pmda_pmid(0,157), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.instrecoverdbfreeze', + 'Instance recovery database freezes', +'The "instance recovery database freeze count" statistic from the +V$SYSSTAT view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,158), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.commitscncached', 'Commit SCN cached', +'The "Commit SCN cached" statistic from the V$SYSSTAT view. The System +Commit Number (SCN) is used to serialize time within a single instance, +and across all instances. This lock resource caches the current value +of the SCN - the value is incremented in response to many database +events, but most notably COMMIT WORK. Access to the SCN lock value to +get and store the SCN is batched on most cluster implementations, so +that every process that needs a new SCN gets one and stores a new value +back on one instance, before the SCN lock is released so that it may be +granted to another instance. Processes get the SC lock once and then +use conversion operations to manipulate the lock value.'); + + $pmda->add_metric(pmda_pmid(0,159), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.cachedscnreferenced', 'Cached Commit SCN referenced', +'The "Cached Commit SCN referenced" statistic from the V$SYSSTAT view. +The SCN (System Commit Number), is generally a timing mechanism Oracle +uses to guarantee ordering of transactions and to enable correct +recovery from failure. They are used for guaranteeing +read-consistency, and checkpointing.'); + + $pmda->add_metric(pmda_pmid(0,160), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.hardparsed', 'Total number of hard parses performed', +'The "parse count (hard)" statistic from the V$SYSSTAT view. This is +the total number of parse calls (real parses). A hard parse means +allocating a workheap and other memory structures, and then building a +parse tree. A hard parse is a very expensive operation in terms of +memory use.'); + + $pmda->add_metric(pmda_pmid(0,161), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.sqlnet.clientrecvs', + 'Total bytes from client via SQL*Net', +'The "bytes received via SQL*Net from client" statistic from the +V$SYSSTAT view. This is the total number of bytes received from the +client over SQL*Net.'); + + $pmda->add_metric(pmda_pmid(0,162), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.sqlnet.clientsends', + 'Total bytes to client via SQL*Net', +'The "bytes sent via SQL*Net to client" statistic from the V$SYSSTAT +view. This is the total number of bytes sent to the client over +SQL*Net.'); + + $pmda->add_metric(pmda_pmid(0,163), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sqlnet.clientroundtrips', + 'Total client SQL*Net roundtrips', +'The "SQL*Net roundtrips to/from client" statistic from the V$SYSSTAT +view. This is the total number of network messages sent to and +received from the client.'); + + $pmda->add_metric(pmda_pmid(0,164), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.sqlnet.dblinkrecvs', + 'Total bytes from dblink via SQL*Net', +'The "bytes received via SQL*Net from dblink" statistic from the +V$SYSSTAT view. This is the total number of bytes received from +the database link over SQL*Net.'); + + $pmda->add_metric(pmda_pmid(0,165), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.sysstat.sqlnet.dblinksends', + 'Total bytes to dblink via SQL*Net', +'The "bytes sent via SQL*Net to dblink" statistic from the V$SYSSTAT +view. This is the total number of bytes sent over a database link.'); + + $pmda->add_metric(pmda_pmid(0,166), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.sqlnet.dblinkroundtrips', + 'Total dblink SQL*Net roundtrips', +'The "SQL*Net roundtrips to/from dblink" statistic from the V$SYSSTAT +view. This is the total number of network messages sent to and +received from a database link.'); + + $pmda->add_metric(pmda_pmid(0,167), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.parallel.queries', 'Total queries parallelized', +'The "queries parallelized" statistic from the V$SYSSTAT view. This is +the number of SELECT statements which have been parallelized.'); + + $pmda->add_metric(pmda_pmid(0,168), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.parallel.DMLstatements', + 'Total DML statements parallelized', +'The "DML statements parallelized" statistic from the V$SYSSTAT view. +This is the number of Data Manipulation Language (DML) statements which +have been parallelized.'); + + $pmda->add_metric(pmda_pmid(0,169), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.parallel.DDLstatements', + 'Total DDL statements parallelized', +'The "DDL statements parallelized" statistic from the V$SYSSTAT view. +This is the number of Data Definition Language (DDL) statements which +have been parallelized.'); + + $pmda->add_metric(pmda_pmid(0,170), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.PX.localsends', 'PX local messages sent', +'The "PX local messages sent" statistic from the V$SYSSTAT view. +This is the number of local messages sent for Parallel Execution.'); + + $pmda->add_metric(pmda_pmid(0,171), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.PX.localrecvs', 'PX local messages received', +'The "PX local messages recv\'d" statistic from the V$SYSSTAT view. +This is the number of local messages received for Parallel Execution.'); + + $pmda->add_metric(pmda_pmid(0,172), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.PX.remotesends', 'PX remote messages sent', +'The "PX remote messages sent" statistic from the V$SYSSTAT view. +This is the number of remote messages sent for Parallel Execution.'); + + $pmda->add_metric(pmda_pmid(0,173), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.PX.remoterecvs', 'PX remote messages received', +'The "PX remote messages recvd" statistic from the V$SYSSTAT view. +This is the number of remote messages received for Parallel Execution.'); + + $pmda->add_metric(pmda_pmid(0,174), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.buffer.pinned', 'Total pinned buffers', +'The "buffer is pinned count" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,175), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.buffer.notpinned', 'Total not pinned buffers', +'The "buffer is not pinned count" statistic from the V$SYSSTAT view. +This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,176), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.sysstat.buffer.nonetopin', 'No buffer to keep pinned count', +'The "no buffer to keep pinned count" statistic from the V$SYSSTAT +view. This metric is not documented by Oracle.'); + + $pmda->add_metric(pmda_pmid(0,177), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.OS.utime', 'OS User time used', +'The "OS User time used" statistic from the V$SYSSTAT view. +Units are milliseconds of CPU user time.'); + + $pmda->add_metric(pmda_pmid(0,178), PM_TYPE_U32, $sid_indom, + PM_SEM_COUNTER, pmda_units(0,1,0,0,PM_TIME_MSEC,0), + 'oracle.sysstat.OS.stime', 'OS System time used', +'The "OS System time used" statistic from the V$SYSSTAT view. +Units are milliseconds of CPU system time.'); +} + +sub setup_rowcache ## row cache statistics from v$rowcache +{ + $pmda->add_metric(pmda_pmid(7,0), PM_TYPE_U32, $rowcache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rowcache.count', + 'Number of entries in this data dictionary cache', +'The total number of data dictionary cache entries, broken down by data +type. This is extracted from the COUNT column of the V$ROWCACHE view.'); + + $pmda->add_metric(pmda_pmid(7,1), PM_TYPE_U32, $rowcache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rowcache.gets', + 'Number of requests for cached information on data dictionary objects', +'The total number of valid data dictionary cache entries, broken down by +data type. This is extracted from the GETS column of the V$ROWCACHE +view.'); + + $pmda->add_metric(pmda_pmid(7,2), PM_TYPE_U32, $rowcache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rowcache.getmisses', + 'Number of data requests resulting in cache misses', +'The total number of data dictionary requests that resulted in cache +misses, broken down by data type. This is extracted from the GETMISSES +column of the V$ROWCACHE view.'); + + $pmda->add_metric(pmda_pmid(7,3), PM_TYPE_U32, $rowcache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rowcache.scans', 'Number of scan requests', +'The total number of data dictionary cache scans, broken down by data +type. This is extracted from the SCANS column of the V$ROWCACHE view.'); + + $pmda->add_metric(pmda_pmid(7,4), PM_TYPE_U32, $rowcache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rowcache.scanmisses', + 'Number of data dictionary cache misses', +'The total number of times data dictionary cache scans failed to find +data in the cache, broken down by data type. This is extracted from +the SCANMISSES column of the V$ROWCACHE view.'); +} + +sub setup_rollstat ## rollback I/O statistics from v$rollstat +{ + $pmda->add_metric(pmda_pmid(4,0), PM_TYPE_U32, $rollback_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.rollback.rssize', 'Size of rollback segment', +'Size in bytes of the rollback segment. This value is obtained from the +RSSIZE column in the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,1), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.writes', + 'Number of bytes written to rollback segment', +'The total number of bytes written to rollback segment. This value is +obtained from the WRITES column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,2), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.xacts', 'Number of active transactions', +'The number of active transactions. This value is obtained from the +XACTS column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,3), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.gets', + 'Number of header gets for rollback segment', +'The number of header gets for the rollback segment. This value is +obtained from the GETS column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,4), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.waits', + 'Number of header waits for rollback segment', +'The number of header gets for the rollback segment. This value is +obtained from the WAIT column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,5), PM_TYPE_U32, $rollback_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.rollback.hwmsize', + 'High water mark of rollback segment size', +'High water mark of rollback segment size. This value is obtained from +the HWMSIZE column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,6), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.shrinks', + 'Number of times rollback segment shrank', +'The number of times the size of the rollback segment decreased, +eliminating additional extents. This value is obtained from the +SHRINKS column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,7), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.wraps', + 'Number of times rollback segment wrapped', +'The number of times the rollback segment wrapped from one extent +to another. This value is obtained from the WRAPS column of the +V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,8), PM_TYPE_U32, $rollback_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.rollback.extends', + 'Number of times rollback segment size extended', +'The number of times the size of the rollback segment grew to include +another extent. This value is obtained from the EXTENDS column of the +V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,9), PM_TYPE_U32, $rollback_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.rollback.avshrink', 'Average shrink size', +'Average of freed extent size for rollback segment. This value is +obtained from the AVESHRINK column of the V$ROLLSTAT view.'); + + $pmda->add_metric(pmda_pmid(4,10), PM_TYPE_U32, $rollback_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_BYTE,0,0), + 'oracle.rollback.avactive', + 'Current size of active entents averaged over time', +'Current average size of extents with uncommitted transaction data. +This value is obtained from the AVEACTIVE column from the V$ROLLSTAT +view.'); +} + +sub setup_reqdist ## request time histogram from v$reqdist +{ + $pmda->add_metric(pmda_pmid(5,0), PM_TYPE_U32, $reqdist_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.reqdist', 'Histogram of database operation request times', +'A histogram of database request times divided into twelve buckets (time +ranges). This is extracted from the V$REQDIST table. +NOTE: + The TIMED_STATISTICS database parameter must be TRUE or this metric + will not return any values.'); +} + +sub setup_object_cache ## cache statistics from v$db_object_cache +{ + $pmda->add_metric(pmda_pmid(9,0), PM_TYPE_U32, $object_cache_indom, + PM_SEM_INSTANT, pmda_units(1,0,0,PM_SPACE_KBYTE,0,0), + 'oracle.object_cache.sharemem', + 'Sharable memory usage in database cache pool by object types', +'The amount of sharable memory in the shared pool consumed by various +objects, divided into object types. The valid object types are: +INDEX, TABLE, CLUSTER, VIEW, SET, SYNONYM, SEQUENCE, PROCEDURE, +FUNCTION, PACKAGE, PACKAGE BODY, TRIGGER, CLASS, OBJECT, USER, DBLINK, +NON_EXISTENT, NOT LOADED and OTHER. +The values for each of these object types are obtained from the +SHARABLE_MEM column of the V$DB_OBJECT_CACHE view.'); + + $pmda->add_metric(pmda_pmid(9,1), PM_TYPE_U32, $object_cache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.object_cache.loads', 'Number of times object loaded', +'The number of times the object has been loaded. This count also +increases when and object has been invalidated. These values are +obtained from the LOADS column of the V$DB_OBJECT_CACHE view.'); + + $pmda->add_metric(pmda_pmid(9,2), PM_TYPE_U32, $object_cache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.object_cache.locks', + 'Number of users currently locking this object', +'The number of users currently locking this object. These values are +obtained from the LOCKS column of the V$DB_OBJECT_CACHE view.'); + + $pmda->add_metric(pmda_pmid(9,3), PM_TYPE_U32, $object_cache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.object_cache.pins', + 'Number of users currently pinning this object', +'The number of users currently pinning this object. These values are +obtained from the PINS column of the V$DB_OBJECT_CACHE view.'); +} + +sub setup_license ## licence data from v$license +{ + $pmda->add_metric(pmda_pmid(1,0), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.license.maxsess', + 'Maximum number of concurrent user sessions', +'The maximum number of concurrent user sessions permitted for the +instance. This value is obtained from the SESSIONS_MAX column of +the V$LICENSE view.'); + + $pmda->add_metric( + pmda_pmid(1,1), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.license.cursess', + 'Current number of concurrent user sessions', +'The current number of concurrent user sessions for the instance. +This value is obtained from the SESSIONS_CURRENT column of the +V$LICENSE view.'); + + $pmda->add_metric( + pmda_pmid(1,2), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.license.warnsess', + 'Warning limit for concurrent user sessions', +'The warning limit for concurrent user sessions for this instance. +This value is obtained from the SESSIONS_WARNING column of the +V$LICENSE view.'); + + $pmda->add_metric( + pmda_pmid(1,3), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.license.highsess', + 'Highest number of concurrent user sessions since instance started', +'The highest number of concurrent user sessions since the instance +started. This value is obtained from the SESSIONS_HIGHWATER column of +the V$LICENSE view.'); + + $pmda->add_metric(pmda_pmid(1,4), PM_TYPE_U32, $sid_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.license.maxusers', + 'Maximum number of named users permitted', +'The maximum number of named users allowed for the database. This value +is obtained from the USERS_MAX column of the V$LICENSE view.'); +} + +sub setup_librarycache ## statistics from v$librarycache +{ + $pmda->add_metric(pmda_pmid(12,0), PM_TYPE_U32, $librarycache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.gets', + 'Number of lock requests for each namespace object', +'The number of times a lock was requested for objects of this +namespace. This value is obtained from the GETS column of the +V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,1), PM_TYPE_U32, $librarycache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.gethits', + 'Number of times objects handle found in memory', +'The number of times an object\'s handle was found in memory. This value +is obtained from the GETHITS column of the V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,2), PM_TYPE_FLOAT, $librarycache_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.gethitratio', + 'Ratio of gethits to hits', +'The ratio of GETHITS to HITS. This value is obtained from the +GETHITRATIO column of the V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,3), PM_TYPE_U32, $librarycache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.pins', + 'Number of times a pin was requested for each namespace object', +'The number of times a PIN was requested for each object of the library +cache namespace. This value is obtained from the PINS column of the +V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,4), PM_TYPE_U32, $librarycache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.pinhits', + 'Number of times all metadata found in memory', +'The number of times that all of the meta data pieces of the library +object were found in memory. This value is obtained from the PINHITS +column of the V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,5), PM_TYPE_FLOAT, $librarycache_indom, + PM_SEM_INSTANT, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.pinhitratio', 'Ratio of pins to pinhits', +'The ratio of PINS to PINHITS. This value is obtained from the +PINHITRATIO column of the V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,6), PM_TYPE_U32, $librarycache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.reloads', 'Number of disk reloads required', +'Any PIN of an object that is not the first PIN performed since the +object handle was created, and which requires loading the object from +the disk. This value is obtained from the RELOADS column of the +V$LIBRARYCACHE view.'); + + $pmda->add_metric(pmda_pmid(12,7), PM_TYPE_U32, $librarycache_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.librarycache.invalidations', + 'Invalidations due to dependent object modifications', +'The total number of times objects in the library cache namespace were +marked invalid due to a dependent object having been modified. This +value is obtained from the INVALIDATIONS column of the V$LIBRARYCACHE +view.'); +} + +sub setup_latch ## latch statistics from v$latch +{ + $pmda->add_metric(pmda_pmid(2,0), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.gets', + 'Number of times obtained a wait', +'The number of times latch obtained a wait. These values are obtained +from the GETS column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,1), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.misses', + 'Number of times obtained a wait but failed on first try', +'The number of times obtained a wait but failed on the first try. These +values are obtained from the MISSES column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,2), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.sleeps', + 'Number of times slept when wanted a wait', +'The number of times slept when wanted a wait. These values are +obtained from the SLEEPS column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,3), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.imgets', + 'Number of times obtained without a wait', +'The number of times latch obtained without a wait. These values are +obtained from the IMMEDIATE_GETS column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,4), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.immisses', + 'Number of times failed to get latch without a wait', +'The number of times failed to get latch without a wait. These values +are obtained from the IMMEDIATE_MISSES column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,5), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.wakes', + 'Number of times a wait was awakened', +'The number of times a wait was awakened. These values are obtained +from the WAITERS_WOKEN column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,6), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.holds', + 'Number of waits while holding a different latch', +'The number of waits while holding a different latch. These values are +obtained from the WAITS_HOLDING_LATCH column of the V$LATCH view.'); + + $pmda->add_metric(pmda_pmid(2,7), PM_TYPE_U32, $latch_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.latch.spingets', + 'Gets that missed first try but succeeded on spin', +'Gets that missed first try but succeeded on spin. These values are +obtained from the SPIN_GETS column of the V$LATCH view.'); +} + +sub setup_backup ## file backup status from v$backup +{ + $pmda->add_metric(pmda_pmid(6,0), PM_TYPE_U32, $file_indom, + PM_SEM_INSTANT, pmda_units(0,0,0,0,0,0), + 'oracle.backup.status', + 'Backup status of online datafiles', +'The Backup status of online datafiles. The status is encoded as an +ASCII character: + not active - ( 45) + active + ( 43) + offline o (111) + normal n (110) + error E ( 69) +This value is extracted from the STATUS column of the V$BACKUP view.'); +} + +sub setup_filestat ## file I/O statistics from v$filestat +{ + $pmda->add_metric(pmda_pmid(3,0), PM_TYPE_U32, $file_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.file.phyrds', + 'Physical reads from database files', +'The number of physical reads from each database file. These values +are obtained from the PHYRDS column in the V$FILESTAT view.'); + + $pmda->add_metric(pmda_pmid(3,1), PM_TYPE_U32, $file_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.file.phywrts', + 'Physical writes to database files', +'The number of times the DBWR process is required to write to each of +the database files. These values are obtained from the PHYWRTS column +in the V$FILESTAT view.'); + + $pmda->add_metric(pmda_pmid(3,2), PM_TYPE_U32, $file_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.file.phyblkrd', + 'Physical blocks read from database files', +'The number of physical blocks read from each database file. These +values are obtained from the PHYBLKRDS column in the V$FILESTAT view.'); + + $pmda->add_metric(pmda_pmid(3,3), PM_TYPE_U32, $file_indom, + PM_SEM_COUNTER, pmda_units(0,0,1,0,0,PM_COUNT_ONE), + 'oracle.file.phyblkwrt', + 'Physical blocks written to database files', +'The number of physical blocks written to each database file. These +values are obtained from the PHYBLKWRT column in the V$FILESTAT view.'); + + $pmda->add_metric(pmda_pmid(3,4), PM_TYPE_U32, $file_indom, + PM_SEM_COUNTER, pmda_units(0,0,0,0,0,0), + 'oracle.file.readtim', + 'Time spent reading from database files', +'The number of milliseconds spent doing reads if the TIMED_STATISTICS +database parameter is true. If this parameter is false, then the +metric will have a value of zero. This value is obtained from the +READTIM column of the V$FILESTAT view.'); + + $pmda->add_metric(pmda_pmid(3,5), PM_TYPE_U32, $file_indom, + PM_SEM_COUNTER, pmda_units(0,0,0,0,0,0), + 'oracle.file.writetim', + 'Time spent writing to database files', +'The number of milliseconds spent doing writes if the TIMED_STATISTICS +database parameter is true. If this parameter is false, then the +metric will have a value of zero. This value is obtained from the +WRITETIM column of the V$FILESTAT view.'); +} + +$pmda = PCP::PMDA->new('oracle', 32); +oracle_metrics_setup(); +oracle_indoms_setup(); + +$pmda->set_fetch_callback(\&oracle_fetch_callback); +$pmda->set_fetch(\&oracle_connection_setup); +$pmda->set_refresh(\&oracle_refresh); +$pmda->set_user('oracle'); +$pmda->run; + +=pod + +=head1 NAME + +pmdaoracle - performance metrics domain agent for Oracle databases + +=head1 DESCRIPTION + +B<pmdaoracle> is a Performance Metrics Domain Agent (PMDA) that obtains +performance metrics from an Oracle database instance and makes them +available to users of the Performance Co-Pilot (PCP) monitor tools. + +B<pmdaoracle> retrieves information from the database by querying the +dynamic performance (V$...) views. +Queries are performed only when metrics are requested from the PMDA to +minimize impact on the database. + +B<pmdaoracle> can monitor multiple Oracle database instances. +If multiple database instances are to be monitored with PCP, each must +be configured during installation. + +The Performance Metrics Collector Daemon, B<pmcd> launches B<pmdaoracle>; +it should not be executed directly. See the installation section below +for instructions on how to configure and start the agent. + +=head1 INSTALLATION + +B<pmdaoracle> uses a configuration file from (in this order): + +=over + +=item * /etc/pcpdbi.conf + +=item * $PCP_PMDAS_DIR/oracle/oracle.conf + +=back + +This file can contain overridden values (Perl code) for the settings +listed at the start of pmdaoracle.pl, namely: + +=over + +=item * database name (see DBI(3) for details) + +=item * database user name + +=item * database pass word + +=back + +Once this is setup, you can access the names and values for the +oracle performance metrics by doing the following as root: + + # cd $PCP_PMDAS_DIR/oracle + # ./Install + +If you want to undo the installation, do the following as root: + + # cd $PCP_PMDAS_DIR/oracle + # ./Remove + +B<pmdaoracle> is launched by pmcd(1) and should never be executed +directly. The Install and Remove scripts notify pmcd(1) when +the agent is installed or removed. + +=head1 FILES + +=over + +=item /etc/pcpdbi.conf + +configuration file for all PCP database monitors + +=item $PCP_VAR_DIR/config/oracle/oracle.conf + +configuration file for B<pmdaoracle> + +=item $PCP_PMDAS_DIR/oracle/oracle.conf + +alternate configuration file for B<pmdaoracle> + +=item $PCP_PMDAS_DIR/oracle/Install + +installation script for the B<pmdaoracle> agent + +=item $PCP_PMDAS_DIR/oracle/Remove + +undo installation script for the B<pmdaoracle> agent + +=item $PCP_LOG_DIR/pmcd/oracle.log + +default log file for error messages from B<pmdaoracle> + +=back + +=head1 SEE ALSO + +pmcd(1), pmdadbping.pl(1) and DBI(3). |