Appendix

The following is a brief description of the components monitored by the 'Instance Monitoring' service.

Monitoring Metrics

Items in the Wait Category list with units marked as SEC and COUNT indicate that each item has separate TIME and COUNT metrics. This also means that the unit for each item's TIME metric is SEC and the unit for the COUNT metric is COUNT.

System Metrics

Category	Component Item	Unit	Description
System	ABLE_MEM	KB	Available memory (This indicator is supported in Linux kernel version 3.10 and above)
System	BUFF_MEM	KB	Buffer memory
System	Blocked Queue	COUNT	Number of blocked processes
System	CACHE_MEM	KB	Cache memory
System	CPU	PERCENT	User, System, and IO individual CPU usage rates
System	CPU (Sys + User)	PERCENT	CPU usage combined for User and System
System	CPU Usage	PERCENT	CPU usage combining User, System, and IO
System	CPU (Idle)	PERCENT	Idle CPU usage
System	CPU (Sys)	PERCENT	Kernel CPU Time
System	DB Memory Usage	PERCENT	DB Memory Usage
System	System Memory Usage	PERCENT	Total memory usage
System	PAGE_IN	COUNT	Number of pages transferred from disk to memory
System	PAGE_OUT	COUNT	Number of pages transferred from memory to disk
System	PGA Usage (Total)	BYTE	DB server process unique memory usage
System	TSM Usage (Total)	BYTE	DB shared memory usage
System	TOTAL_MEMORY	BYTE	DB memory size
System	TOTAL_MEM	KB	Total memory size
System	TOTAL_SWAP	KB	Total SWAP file size
System	USED_MEM	KB	Memory size in use
System	USED_SWAP	KB	SWAP size in use
System	CURRENT_TSN	COUNT	Current TSN value

Session Metrics

Category	Component Item	Unit	Description
Session	TOTAL_SESSION_COUNT	COUNT	Total number of sessions
Session	Lock Waiter Session Count	COUNT	Number of sessions waiting to acquire WLock at the specified log time (in seconds)
Session	Session Count	COUNT	Active Session, Inactive Session Composite Value
Session	Long Running Session Count	COUNT	Number of sessions corresponding to each threshold range of ELAPSED_TIME
Session	Enqueue Waiting Session Count	COUNT	The number of sessions corresponding to each threshold range of WAIT_TIME
Session	ACTIVE_SESSION_COUNT	COUNT	Number of active sessions
Session	RUNNING_SESSION_COUNT	COUNT	The number of sessions whose status is RUNNING at the time of session data collection

Stat Metrics

Category	Component Item	Unit	Description
Stat	BLOCK_DISK_READ	BLOCK	block disk read
Stat	MULTI_BLOCK_DISK_READ	BLOCK	multi block disk read - blocks
Stat	CONSISTENT_MULTI_BLOCK_GETS	BLOCK	consistent multi gets - blocks
Stat	CONSISTENT_BLOCK_GETS	COUNT	consistent block gets
Stat	CONSISTENT_BLOCK_GETS_READONLY_PIN	COUNT	consistent block gets - readonly pin
Stat	CONSISTENT_BLOCK_GETS_EXAMINE	COUNT	consistent block gets examine
Stat	CONSISTENT_BLOCK_GETS_EXAMINE_NOWAIT	COUNT	consistent block gets examine - nowait - success
Stat	CURRENT_BLOCK_GETS	COUNT	current block gets
Stat	CURRENT_BLOCK_GETS_NOWAIT	COUNT	current block gets - no wait - success
Stat	CURRENT_BLOCK_GETS_EXAMINE	COUNT	current block gets examine
Stat	CURRENT_BLOCK_GETS_EXAMINE_NOWAIT	COUNT	current block gets examine - no wait - success
Stat	TOTAL_PARSE_COUNT	COUNT	parse count (total)
Stat	HARD_PARSE_COUNT	COUNT	parse count (hard)
Stat	REDO_ENTRIES	COUNT	redo entries
Stat	REDO_LOG_SIZE	BYTE	redo log size
Stat	REDO_WRITE	COUNT	redo write
Stat	REDO_WRITE_MULTI	COUNT	redo write multi
Stat	PHYSICAL_WRITE	BLOCK	dbwr written block count
Stat	REQ_SERVICE_TIME	SEC	req service time
Stat	DB_CPU_TIME	SEC	DB CPU time
Stat	USER_COMMIT	COUNT	the number of user commits performed
Stat	USER_ROLLBACKS	COUNT	user rollbacks
Stat	EXECUTE_COUNT	COUNT	execute count
Stat	PHYSICAL_READS	BLOCK
Stat	LOGICAL_READS	BLOCK
Stat	BUFFER_CACHE_HIT	PERCENT	logical reads / (logical reads + physical reads)

Stat-TAC Metrics

Category	Component Item	Unit	Description
Stat-TAC	NUMBER_OF_WAIT_LOCKS_GRANTED_FROM_THE_MASTER	COUNT	Number of wait-locks granted from the master
Stat-TAC	TOTAL_ROUND_TRIP_TIMES_TO_GRANT_WAIT_LOCK	COUNT	Total Round Trip Times to grant wait-lock
Stat-TAC	CURRENT_BLOCK_RECEIVED	BLOCK	current block received
Stat-TAC	CURRENT_BLOCK_RECEIVED_RTT	SEC	current block received RTT
Stat-TAC	CR_BLOCK_RECEIVED	BLOCK	CR block received
Stat-TAC	CR_BLOCK_RECEIVED_RTT	SEC	CR block received RTT
Stat-TAC	CURRENT_BLOCK_SEND	BLOCK	current block send
Stat-TAC	CURRENT_BLOCK_SEND_FAIL	BLOCK	current block send fail
Stat-TAC	CURRENT_BLOCK_SEND_TIME	SEC	current block send time
Stat-TAC	CR_BLOCK_SEND	BLOCK	CR block send
Stat-TAC	CR_BLOCK_SEND_FAIL	BLOCK	CR block send fail
Stat-TAC	CR_BLOCK_SEND_TIME	SEC	CR block send time
Stat-TAC	INC_MESSAGES_RECEIVED	COUNT	INC messages received
Stat-TAC	INC_MESSAGES_RECEIVED_TIME	SEC	INC messages received time
Stat-TAC	INC_MESSAGES_RECEIVED_SIZE	BYTE	INC messages received size
Stat-TAC	INC_MESSAGES_RECEIVED_BY_RETRY	COUNT	INC messages received by retry
Stat-TAC	INC_MESSAGES_RECEIVED_BY_RETRY_DELAY_TIME	SEC	INC messages received by retry - delay time
Stat-TAC	INC_MESSAGES_RECEIVED_BY_BATCH	COUNT	INC messages received by batch
Stat-TAC	INC_MESSAGES_RECEIVED_BY_BATCH_TIME	SEC	INC messages received by batch - time
Stat-TAC	INC_PACKETS_RECEIVED	PACKET	INC packets received
Stat-TAC	INC_PACKETS_RECEIVED_SIZE	BYTE	INC packets received size
Stat-TAC	INC_MESSAGES_SENT	COUNT	INC messages sent
Stat-TAC	INC_MESSAGES_SENT_TIME	SEC	INC messages sent time
Stat-TAC	INC_MESSAGES_SENT_SIZE	BYTE	INC messages sent size
Stat-TAC	INC_MESSAGES_SENT_BY_RETRY	COUNT	INC messages sent by retry
Stat-TAC	INC_MESSAGES_SENT_BY_RETRY_DELAY_TIME	SEC	INC messages sent by retry - delay time
Stat-TAC	INC_MESSAGES_SENT_BY_BATCH	COUNT	INC messages sent by batch
Stat-TAC	INC_MESSAGES_SENT_BY_BATCH_SUCCESS_MESSAGES	COUNT	INC messages sent by batch - success messages
Stat-TAC	INC_MESSAGES_SENT_FROM_SEND_QUEUE_TIME	SEC	INC messages sent from send queue - time
Stat-TAC	INC_PACKETS_SENT	PACKET	INC packets sent
Stat-TAC	INC_PACKETS_SENT_SIZE	BYTE	INC packets sent size

Wait Metrics

Category	Component Item	Unit	Description
Wait	WE_BUF_WAIT	SEC, COUNT	This value is high when multiple sessions make modification and reference requests for the same data block in the buffer cache. If multiple sessions modify a data block in the buffer cache simultaneously, or if one session modifies a data block while another session references its contents, data consistency issues may arise. Therefore, during data block access, if another session is already modifying or referencing the data block, the current session must wait until the previous modification or reference operation completes. This event indicates the time spent waiting during this process.
Wait	WE_BUF_WRITE	SEC, COUNT	The DB writer periodically writes modified data blocks from the buffer cache to disk. While the DB writer is performing disk writes, if another session modifies the data block, the DB writer may write the data block to disk in an inconsistent state, i.e., a state where modifications are in progress. Therefore, if the DB writer is in the process of writing, any session attempting to modify the data block must wait until the write is complete. This event indicates the time spent waiting during this process.
Wait	WE_BUF_FREE	SEC, COUNT	When loading new data blocks into the buffer cache or creating CR blocks, free buffers must be secured. This event indicates the time spent waiting during the free buffer acquisition process. If the buffer cache size is too small relative to the load using the buffer cache, or if the database writer is slow in writing dirty blocks to disk, the free buffer wait time may be high.
Wait	WE_LGWR_ARCHIVE	SEC, COUNT	This indicates the time the log writer waits for the redo log archiving operation to complete before performing a redo log switch. If the I/O speed to the disk designated as the archive directory is slow, this event may be measured at a high level.
Wait	WE_LGWR_LNW	SEC, COUNT	When there is a standby instance operating in LGWR SYNC mode, the log writer verifies that the redo log has been written to both the primary and standby instances. This event indicates the time the log writer waited for the redo log to be written to the standby instance.
Wait	WE_LOG_FLUSH_COMMIT	SEC, COUNT	This event indicates the time a session waits for a redo log flush request to be completed while performing a commit operation. For a transaction commit to complete, all redo logs left by the transaction must be flushed to the redo log file. The transaction-modified data blocks do not need to be flushed to disk to maintain commit consistency. In the event of a failure, if the server goes down or the machine shuts down while the redo log is flushed, the DB server performs cache recovery and transaction recovery upon subsequent boot. During cache recovery, the redo log is reapplied to restore the buffer cache to its state before it was flushed. During transaction recovery, since the commit itself leaves a redo log, an uncommitted transaction list is created, and the transactions in that list are rolled back. Through these actions, the DB server maintains consistency with just the redo log flush during commit.
Wait	WE_TSN_SYNC_COMMIT	SEC, COUNT	The time it takes for a session to request and complete TSN synchronization between nodes while performing a commit operation in the TAC.
Wait	WE_LOG_FLUSH_SPACE	SEC, COUNT	When a session modifies a data block, it creates a redo log containing the modified contents and applies it to the data block. During this process, the created redo log is recorded in the redo log buffer located in shared memory. When recording the redo log created in the redo buffer, if there is insufficient space in the redo buffer, the log writer must wait until the log writer flushes the redo log recorded in the redo log buffer to create space in the redo log buffer. This event indicates the time the log writer waits for the log writer to flush the redo log buffer to create free space in the redo buffer so that a new redo log can be written to the redo log buffer.
Wait	WE_LOG_FLUSH_REQ	SEC, COUNT	Indicates the time waited until the redo log flush is completed when a request is made to flush the contents of the redo log loaded in the redo buffer to the redo log file. This includes both cases where the user requests a redo log flush through DDL and cases where the DB server internally requests a redo log flush. Even if a redo log flush is not explicitly requested, it occurs when a TX commit occurs, a certain amount of redo log is loaded into the redo buffer, or a certain amount of time has elapsed.
Wait	WE_CKPT_WAIT	SEC, COUNT	This event indicates the time elapsed while waiting for a DB checkpoint requested by a specific point in time until the checkpoint is completed. A DB checkpoint refers to the process of writing modified data from the buffer cache to disk up to a specific point in time. When there are many modified data blocks in the buffer cache, a large number of data blocks may be written to disk during the checkpoint process. Therefore, the checkpoint process may occupy a significant amount of disk bandwidth and potentially degrade the performance of the DB instance.
Wait	WE_RT_INFLOW_WAIT	SEC, COUNT	When session flow control is enabled, this indicates the time spent waiting to be assigned an available session.
Wait	WE_SMR_REPLAY	SEC, COUNT	Indicates the time spent waiting for the Standby Managed Recovery process (SMR) to complete replay up to a specific point in time.
Wait	WE_PE_COMM	SEC, COUNT	Indicates the time the Slave Session waits for a message from the QC. When Parallel Execution begins, the QC session that manages the entire query assigns slave sessions to perform parallel processing. This event occurs while waiting for the slave session to be assigned.
Wait	WE_PE_ENQ	SEC, COUNT	Indicates the time a producer slave session waits to allocate a buffer from a consumer slave session. During parallel execution, producer slave sessions that generate intermediate results transmit these results to consumer slave sessions that utilize them. If the intermediate result storage buffer of a consumer slave session becomes full during this process, the producer slave session waits until buffer space becomes available, triggering this event.
Wait	WE_PE_DEQ	SEC, COUNT	This indicates the time that the consumer slave session waits for the producer slave session to fill the buffer. When parallel execution is performed, the producer slave session that generates intermediate results transmits those results to the consumer slave session that uses them to perform its tasks. During this process, if the intermediate result storage buffer of the consumer slave session is empty, an event occurs where the consumer slave session waits until the producer slave session fills the buffer further.
Wait	WE_ACF_MTX_RW	SEC, COUNT	Indicates the time spent waiting for a read/write mutex lock for synchronization in the active cluster.
Wait	WE_SVC_TX	SEC, COUNT	Indicates the time spent waiting for the user transaction to complete the index split operation of the service transaction.
Wait	WE_TX_RECO_SUSPEND	SEC, COUNT	Indicates the time the user waited until manually forcing a commit or rollback during TX recovery.
Wait	WE_CWS_AST	SEC, COUNT	Indicates the time spent waiting for a response to a wait-lock request sent to another node.
Wait	WE_CCC_AST_CR	SEC, COUNT	Indicates the time spent waiting for a response to a Consistent Read (CR) block request sent to another node.
Wait	WE_CCC_AST_CUR	SEC, COUNT	Indicates the time spent waiting for a response to a Current Block request sent to another node.
Wait	WE_CR_BUF_BUSY_LOCAL	SEC, COUNT	Indicates the time spent waiting for the CR block request of the local node to finish.
Wait	WE_CR_BUF_BUSY_GLOBAL	SEC, COUNT	Indicates the time to wait for another node's CR block request that is already in progress to finish.
Wait	WE_CUR_BUF_BUSY_LOCAL	SEC, COUNT	Indicates the time that the CUR block request waits for other session requests on the same node that are already in progress to finish.
Wait	WE_CUR_BUF_BUSY_GLOBAL	SEC, COUNT	Indicates the time to wait for other node requests that are already in progress to finish.
Wait	WE_GV_REQ	SEC, COUNT	Indicates the time spent waiting to receive a new global view execution request from another node.
Wait	WE_GV_REPLY	SEC, COUNT	Indicates the time spent waiting for the result set from another node in response to a global view request.
Wait	WE_SEARCH_SPACE_REPLY	SEC, COUNT	Indicates the time spent waiting for search space results from other nodes.
Wait	WE_DDL_CSR_INVAL	SEC, COUNT	deprecated
Wait	WE_DDL_CHANGE_UNDO_TS	SEC, COUNT	Indicates the time to wait when changing the undo tablespace.
Wait	WE_PEQ	SEC, COUNT	Indicates the time spent waiting in the queue for parallel execution.
Wait	WE_ALERT	SEC, COUNT	Indicates the time waiting for an alert.
Wait	WE_WLOCK_CF	SEC, COUNT	WLOCK acquired internally during Control File creation/loading/modification operations.
Wait	WE_WLOCK_TX	SEC, COUNT	A WLOCK acquired to prevent tx with the same id from starting in multiple sessions
Wait	WE_WLOCK_ST_SGMT	SEC, COUNT	WLOCK acquired when allocating/deallocating an extent in a segment.
Wait	WE_WLOCK_SPLIT	SEC, COUNT	WLOCK acquired when performing a split operation on a specific index block (WLOCK used before the index split feature was improved).
Wait	WE_WLOCK_DML	SEC, COUNT	WLOCK acquired when performing DML/DDL operations on a table or associated object.
Wait	WE_WLOCK_USER	SEC, COUNT	WLOCK acquired during profile changes, authentication, etc. for DB users.
Wait	WE_WLOCK_DD_OBJ	SEC, COUNT	WLOCK acquired internally during DDL, DD Cache lookup, etc. for DB objects.
Wait	WE_WLOCK_DD_USER	SEC, COUNT	WLOCK acquired internally during DDL, DD Cache lookups, etc. for DB users.
Wait	WE_WLOCK_DD_SGMT	SEC, COUNT	WLOCK acquired internally during operations such as DD cache lookups for segments within the DB.
Wait	WE_WLOCK_DD_TS	SEC, COUNT	WLOCK acquired internally when performing DDL on a tablespace in the DB or when creating an object belonging to the tablespace.
Wait	WE_WLOCK_DD_TS_REF	SEC, COUNT	WLOCK acquired internally when creating objects belonging to the DB tablespace.
Wait	WE_WLOCK_DD_OBJAUTH	SEC, COUNT	WLOCK internally acquired during object permission checks in SQL within the DB
Wait	WE_WLOCK_DD_SYSAUTH	SEC, COUNT	WLOCK obtained internally during system permission checks in SQL within the DB.
Wait	WE_WLOCK_DD_PSMIR	SEC, COUNT	WLOCK acquired internally during PSM execution, DD cache lookup, etc., for PSM units in the DB.
Wait	WE_WLOCK_DD_PENDING_TX	SEC, COUNT	WLOCK acquired internally to prevent multiple sessions from committing or rolling back the same transaction simultaneously.
Wait	WE_WLOCK_DD_PARTOBJ	SEC, COUNT	WLOCK acquired internally in Table, Partition, Index DDL, etc.
Wait	WE_WLOCK_SEQ_GET_NEXTVAL	SEC, COUNT	WLOCK acquired internally during value lookups or DDL operations on a sequence.
Wait	WE_WLOCK_DDL_CREATE_TS	SEC, COUNT	WLOCK acquired internally during tablespace creation.
Wait	WE_WLOCK_DDL_CREATE_DF	SEC, COUNT	WLOCK acquired to protect the exclusive execution of datafile/logfile add/create/drop/status changes.
Wait	WE_WLOCK_DDL_CREATE_CON	SEC, COUNT	WLOCK acquired internally during constraint creation.
Wait	WE_WLOCK_XA_BUCKET	SEC, COUNT	WLOCK acquired per bucket set when accessing the XA hashtable bucket
Wait	WE_WLOCK_XA_GLB	SEC, COUNT	WLOCK acquired when accessing XA global tx information.
Wait	WE_WLOCK_XA_BCH	SEC, COUNT	WLOCK acquired when accessing XA branch information.
Wait	WE_WLOCK_XA_VT	SEC, COUNT	Acquired to prevent transaction information from being deleted due to commit/rollback during XA-related VT creation.
Wait	WE_WLOCK_DX	SEC, COUNT	Acquired to prevent SQL execution from occurring simultaneously between sessions using tightly coupled XA branches.
Wait	WE_WLOCK_IR	SEC, COUNT	An internal WLOCK acquired to check whether IR (Instance Recovery) is in progress
Wait	WE_WLOCK_TEMP_GRANULE	SEC, COUNT	WLOCK obtained to ensure that the space allocated in the global temp tablespace cannot be used by other nodes.
Wait	WE_WLOCK_CLEANUP_DROPPED_SGMT	SEC, COUNT	WLOCK acquired internally when actually cleaning up segments dropped due to DDL
Wait	WE_WLOCK_MV_RFSH	SEC, COUNT	WLOCK acquired internally during Mview refresh
Wait	WE_WLOCK_DDL_RECOMPILE	SEC, COUNT	WLOCK acquired internally during PSM Recompile
Wait	WE_WLOCK_ASYSRECOMPILE	SEC, COUNT	WLOCK acquired internally when Alter system recompile all is executed.
Wait	WE_WLOCK_DBMS_PIPE_LIST	SEC, COUNT	WLOCK acquired internally when using the DBMS_PIPE package.
Wait	WE_WLOCK_DP_TEMP_SGMT	SEC, COUNT	Acquired to ensure that cleanup operations cannot clean up the temp segment while the PDP is still running. WLOCK
Wait	WE_WLOCK_STANDBY	SEC, COUNT	WLOCK acquired to ensure that the Log Network Reader process runs exclusively within the DB.
Wait	WE_WLOCK_SMR	SEC, COUNT	WLOCK acquired by the Standby Managed Recovery process to perform independently during standby TAC multinode.
Wait	WE_WLOCK_LNR_REVERSE_SYNC	SEC, COUNT	WLOCK acquired for the standby forced reverse synchronization function to be performed independently.
Wait	WE_WLOCK_AUTO_COALESCE	SEC, COUNT	WLOCK acquired to perform index auto coalesce per session
Wait	WE_WLOCK_XTB_TIMEOUT_CHECK	SEC, COUNT	WLOCK to prevent duplicate timeout checks for XA sessions
Wait	WE_WLOCK_REVALIDATE_OBJ	SEC, COUNT	WLOCK acquired internally during revalidation of invalid DB objects
Wait	WE_WLOCK_UPDATE_USER_STATUS	SEC, COUNT	WLOCK acquired internally by the Profile processing performed periodically.
Wait	WE_WLOCK_L1_LOCAL_CACHE	SEC, COUNT	Acquired to prevent multiple sessions from simultaneously requesting L1 distribution from the same segment master.
Wait	WE_WLOCK_SC_LRU_CACHE_OUT	SEC, COUNT	WLOCK acquired when performing shared cache LRU cache out.
Wait	WE_WLOCK_DBMS_LOCK	SEC, COUNT	WLOCK used when using the DBMS_LOCK package.
Wait	WE_WLOCK_BITMAP_INDEX	SEC, COUNT	WLOCK acquired to add a key (entry) to the bitmap index.
Wait	WE_WLOCK_BCT	SEC, COUNT	WLOCK acquired to change the BCT (Block Change Tracker) status.
Wait	WE_WLOCK_IMCS	SEC, COUNT	WLOCK acquired for in-memory column store scan or populate operations.
Wait	WE_WLOCK_IMCS_PRIORITY_POPULATE	SEC, COUNT	WLOCK acquired for in-memory column store priority populate operations.
Wait	WE_WLOCK_LGWR_STATUS	SEC, COUNT	Acquired to wait for completion after requesting to stop/resume I/O operations of the log writer thread and check pointer thread. WLOCK
Wait	WE_WLOCK_FB	SEC, COUNT	Acquired to ensure exclusive execution when changing the flashback thread state.
Wait	WE_WLOCK_RMGR	SEC, COUNT	A WLOCK used to protect the independence of RMGR jobs in the DB based on their status.
Wait	WE_WLOCK_TS_INVALIDATE	SEC, COUNT	Acquired to prevent duplicate execution of global buffer cache invalidation operations during tablespace offline or drop operations.
Wait	WE_WLOCK_CF_TS	SEC, COUNT	WLOCK acquired when performing Tablespace create/drop and Tablespace datafile add/rename
Wait	WE_WLOCK_JOB	SEC, COUNT	WLOCK acquired to prevent a job from being executed multiple times by different workers.
Wait	WE_WLOCK_SESSKEY	SEC, COUNT	WLOCK acquired internally when decrypting connection information received from the client in encrypted form.
Wait	WE_WLOCK_CONTEXT_INDEX	SEC, COUNT	WLOCK obtained internally when synchronizing the context index.
Wait	WE_WLOCK_RT_STANDBY	SEC, COUNT	WLOCK acquired by the Log Network Writer process to perform synchronization with the standby DB and redo thread that correspond to itself.
Wait	WE_WLOCK_USGMT	SEC, COUNT	WLOCK acquired when performing undo segment modification operations such as undo segment creation, ucache load/reload, etc.
Wait	WE_WLOCK_RSRC	SEC, COUNT	WLOCK used to protect consumer group information modifications
Wait	WE_WLOCK_SETPARAM	SEC, COUNT	WLOCK acquired when using Alter system set parameter
Wait	WE_WLOCK_IMT	SEC, COUNT	WLOCK acquired when initializing the in-memory tablespace and loading the in-memory tablespace DD information.
Wait	WE_WLOCK_EXPAND_RSB	SEC, COUNT	WLOCK acquired to create additional memory context (rsb) related to the global buffer cache in the TAC environment.
Wait	WE_WLOCK_EXPAND_LKBSET	SEC, COUNT	WLOCK acquired to create additional memory context (lkb) related to the global lock of the data block in the TAC environment.
Wait	WE_JC_BUF_DISK_READ	SEC, COUNT	Represents the number of times each DB block was read (single). The block disk read time is the time spent waiting to read the block from the disk and load it into the buffer cache. Reads one block from the disk into the buffer. The value indicates the number of reads.
Wait	WE_JC_BUF_DISK_READM	SEC, COUNT	Represents the number of DB blocks read (multiple). This occurs when multiple blocks are read into the buffer simultaneously from the disk, such as during a full table scan where many consecutive blocks are read at once. The value indicates the number of times disk read was called, and the size represents the number of blocks read from the disk. The time indicates the duration of the disk read operation.
Wait	WE_JC_SSGMT_READ_TIME	SEC, COUNT	Indicates the number of times the temporary segment in the sort segment area was read, the number of extents read, and the time taken.
Wait	WE_JC_SSGMT_WRITE_TIME	SEC, COUNT	Indicates the number of times the temporary segment in the Sort Segment area was written, the number of extents used, and the time taken.
Wait	WE_JC_BUF_DISK_READM_PGA	SEC, COUNT	Indicates the number of times a multi-block disk read was requested to the PGA, the number of blocks actually read, and the time taken. Occurs when a multi-block disk read is performed on the PGA rather than the buffer cache.
Wait	WE_JC_DPBUF_WAIT_WRITE	SEC, COUNT	This statistic indicates the number of times and the write time for writing the contents of blocks loaded into the direct path buffer during Direct Path Load (DPL) or Direct Path Import (DPI) operations.
Wait	WE_JC_REDO_SLEEP	SEC, COUNT	When using the redo resource manager feature, this event calculates the redo log generation rate and the amount of redo log generated by each session for flow control purposes, and processes the session to wait for a certain amount of time when the session is accumulating redo logs in the redo buffer. This event indicates the number of times and the duration the session waited during this process.
Wait	WE_JC_FDPOOL_INVL	SEC, COUNT	When invalidating a cached fdpool due to a datafile drop, this indicates the number of times and duration that other wthr referencing the same fdpool wait until the fdpool is released.
Wait	WE_JC_FARC_WRITE	SEC, COUNT	Indicates the number of times, number of blocks, and time taken for FARC to write to disk when generating a flashback archive logfile.
Wait	WE_SPIN_BUF_BUCKET	SEC, COUNT	Displays statistical information related to the spinlock that protects the hash bucket chain in the buffer cache. The buffer cache uses a hash bucket table as a data structure to quickly access requested blocks, and each hash bucket is organized into a chain to resolve hash collisions. When accessing a block, the hash bucket chain is searched, and this spinlock is acquired to protect the chain structure. Due to load characteristics, such as severe hot block contention or a small hash bucket table size, contention for this spinlock may increase.
Wait	WE_SPIN_BUF_WS	SEC, COUNT	This indicates statistical information related to the spinlock that protects the working set of the buffer cache. To mitigate contention that occurs when multiple sessions access the buffer cache simultaneously, the buffer cache divides buffers into small units called working sets for management. Each working set manages the same number of buffers, and when a session accesses a working set, it acquires this spinlock to protect the internal management structure of the working set. If the number of working sets is small compared to the buffer cache size, the contention for this spinlock may increase.
Wait	WE_SPIN_SHP_ALLOC_LC	SEC, COUNT	This spinlock is for the slave of the shared pool allocator that is shared and written by threads across multiple processes.
Wait	WE_SPIN_SHP_ALLOC_DD	SEC, COUNT	This is a spinlock for the slave of the shared pool allocator that is shared and used by threads in multiple processes.
Wait	WE_SPIN_SHP_ALLOC_MISC	SEC, COUNT	A spinlock for the slave of a shared pool allocator that is shared and used by threads in multiple processes.
Wait	WE_SPIN_SHP_ALLOC_SLAB	SEC, COUNT	A spinlock for the slave of a shared pool allocator that is shared and used by threads in multiple processes.
Wait	WE_SPIN_SHP_ALLOC_SUPER	SEC, COUNT	A spinlock for the shared pool allocator shared and used by threads in multiple processes.
Wait	WE_SPIN_ALLOC_LRU	SEC, COUNT	A spinlock that protects the LRU list of recreatable chunks that can be reused among the recreatable chunks in the shared pool.

SQL Metrics

Category	Component Item	Unit	Description
SQL	Response Time	SEC	The execution time of SQL Trace that took longer than a specified time to execute.