> For the complete documentation index, see [llms.txt](https://docs.tibero.com/sysmasterdb/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.tibero.com/sysmasterdb/8.4_manual/appendix/appendix-a.-instance-monitoring-indicators.md).

# Appendix A. Instance Monitoring Indicators

다음은 '[Instance Monitoring](/sysmasterdb/8.4_manual/realtime/main-monitoring/instance-monitoring.md)' 서비스에서 제공하는 모니터링 대상 지표에 대한 간략한 설명이다.

## Monitoring Indicators

지표 이름은 화면에 표시되는 이름 기준이다. Wait Category의 항목은 화면에서 Time 지표와 Count 지표로 각각 제공되며(예: We Buf Wait Time, We Buf Wait Count), 아래 표의 Indicator는 두 지표의 공통 이름이다. 단위가 SEC, COUNT로 표기된 것은 Time 지표의 단위가 SEC, Count 지표의 단위가 COUNT임을 뜻한다.

### System Indicators&#x20;

<table><thead><tr><th width="167">Category</th><th>Indicator</th><th>Unit</th><th>Description</th></tr></thead><tbody><tr><td>System</td><td>Blocked Queue</td><td>COUNT</td><td>블록된 프로세스 개수</td></tr><tr><td>System</td><td>CPU (Idle)</td><td>PERCENT</td><td>Idle CPU 점유율</td></tr><tr><td>System</td><td>CPU (Sys)</td><td>PERCENT</td><td>커널(System) 모드 CPU 점유율</td></tr><tr><td>System</td><td>CPU (Sys + User)</td><td>PERCENT</td><td>User, System을 합친 CPU 점유율</td></tr><tr><td>System</td><td>CPU (Sys + User + IO)</td><td>PERCENT</td><td>User, System, IO를 합친 CPU 점유율</td></tr><tr><td>System</td><td>CPU Usage</td><td>PERCENT</td><td>User, System, IO, Steal 전체 합산 CPU 점유율</td></tr><tr><td>System</td><td>Current Tsn</td><td>NUMBER</td><td>현재 TSN(Tibero System Number)의 값</td></tr><tr><td>System</td><td>DB Memory Usage</td><td>PERCENT</td><td>DB 메모리 사용량</td></tr><tr><td>System</td><td>Memory Buffer Size</td><td>MB</td><td>I/O 버퍼에 할당된 메모리 크기</td></tr><tr><td>System</td><td>Memory Cache Size</td><td>MB</td><td>캐시에 할당된 메모리 크기</td></tr><tr><td>System</td><td>Memory Free Size</td><td>MB</td><td>현재 사용 가능한 메모리 크기</td></tr><tr><td>System</td><td>Memory Target</td><td>BYTE</td><td>DB 메모리 크기</td></tr><tr><td>System</td><td>Memory Total Size</td><td>MB</td><td>총 메모리 크기</td></tr><tr><td>System</td><td>Memory Usage</td><td>PERCENT</td><td>총 메모리 사용률</td></tr><tr><td>System</td><td>Memory Used Size</td><td>MB</td><td>사용 중인 메모리 크기</td></tr><tr><td>System</td><td>PGA Usage (Total)</td><td>BYTE</td><td>DB 서버 프로세스 고유 점유 메모리 사용량</td></tr><tr><td>System</td><td>Page In</td><td>COUNT</td><td>SWAP 파일에서 메모리로 전환되는 페이지 개수</td></tr><tr><td>System</td><td>Page Out</td><td>COUNT</td><td>메모리에서 디스크 SWAP 파일로 전환되는 페이지 개수</td></tr><tr><td>System</td><td>Session Usage</td><td>PERCENT</td><td>할당 가능한 전체 세션 수 대비 현재 사용 중인 세션 수의 비율</td></tr><tr><td>System</td><td>TPS</td><td>COUNT</td><td>Transactions per Second</td></tr><tr><td>System</td><td>TSM Usage (Total)</td><td>BYTE</td><td>DB 공유 메모리 사용량</td></tr><tr><td>System</td><td>Total Swap Size</td><td>MB</td><td>전체 Swap 파일 크기</td></tr><tr><td>System</td><td>Used Swap Size</td><td>MB</td><td>Swap 파일 사용량</td></tr></tbody></table>

### Session Indicators

| Category | Indicator                                 | Unit  | Description                                                                                         |
| -------- | ----------------------------------------- | ----- | --------------------------------------------------------------------------------------------------- |
| Session  | Active Session Count                      | COUNT | 세션 데이터 수집 시점에, 활성 상태(STATUS가 RUNNING, TX\_RECOVERING, ROLLING\_BACK, SESS\_CLEANUP, CLOSING)인 세션 개수 |
| Session  | Enqueue Waiting Session Count             | COUNT | Wait Time이 각 임계값 범위에 해당하는 세션의 개수                                                                    |
| Session  | Lock Waiter Session Count                 | COUNT | 해당 초(Log Time)에 WLock을 획득하기 위해 기다리고 있는 세션의 개수                                                       |
| Session  | Long Running Session Count                | COUNT | Elapsed Time이 각 임계값 범위에 해당하는 세션의 개수                                                                 |
| Session  | Running Session Count                     | COUNT | 세션 데이터 수집 시점에, 해당 세션 상태가 RUNNING인 세션 개수                                                             |
| Session  | Session Count (Running, Active, Inactive) | COUNT | Running Session, Active Session, Inactive Session 개수의 복합 값                                          |
| Session  | Total Foreground Session Count            | COUNT | 백그라운드 전용 세션을 제외한, 할당 가능한 전체 세션 개수                                                                   |
| Session  | Total Session Count                       | COUNT | DB에서 할당 가능한 전체 세션 개수                                                                                |

### Stat Indicators

| Category | Indicator                            | 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   | Number of physical read blocks retrieved from disk instead of cache       |
| Stat     | Logical Reads                        | BLOCK   | Number of reads from memory instead of physical disk during SQL execution |
| Stat     | Buffer Cache Hit                     | PERCENT | logical reads / (logical reads + physical reads)                          |

### Stat-TAC Indicators

| Category | Indicator                                    | 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 Indicators

| Category | Indicator                       | Unit       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| -------- | ------------------------------- | ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Wait     | We Buf Wait                     | SEC, COUNT | Buffer cache 상에서 동일 data block에 대한 여러 세션의 수정 및 참조 요청이 몰리는 경우 높게 측정된다. 여러 session이 buffer cache의 data block을 동시에 수정하거나, 한 session이 data block을 수정하는 도중에 다른 session이 해당 data block 내용을 참조하게 되면 data 정합성이 깨지는 문제가 발생할 수 있다. 따라서 data block 접근 과정에서 다른 session이 이미 data block을 수정 중이거나 참조 중이라면 앞선 수정 혹은 참조 작업이 끝날 때까지 대기하게 되는데, 해당 event는 이 과정에서 대기한 시간을 나타낸다.                                                                                                                                                                                                                                                                            |
| Wait     | We Buf Write                    | SEC, COUNT | DB writer는 일정 주기로 buffer cache에서 수정된 data block들을 disk에 write한다. DB writer가 disk write를 진행하는 동안 다른 세션이 data block을 수정하게 되면, DB writer는 일관되지 않은 상태, 즉 수정이 진행 중인 상태의 data block을 disk에 write하는 일이 발생할 수 있다. 따라서 DB writer가 write 진행 중인 경우 해당 data block을 수정하고자 하는 session은 write가 끝날 때까지 대기하게 되는데, 해당 event는 이 과정에서 소요된 대기 시간을 나타낸다.                                                                                                                                                                                                                                                                                                    |
| Wait     | We Buf Free                     | SEC, COUNT | Buffer cache에 새로운 data block을 적재하거나 CR block을 생성할 때는 free buffer를 확보하는데, 해당 event는 free buffer 확보 과정에서 대기한 시간을 나타낸다. Buffer cache를 사용하는 부하량 대비 buffer cache의 size가 너무 작거나, database writer가 dirty block을 disk로 쓰는 작업이 느린 경우 free buffer 대기 시간이 높게 측정될 수 있다.                                                                                                                                                                                                                                                                                                                                                                           |
| Wait     | We Lgwr Archive                 | SEC, COUNT | Log writer가 redo log switch를 위해 redo log archiving 작업이 완료될 때까지 대기한 시간을 나타낸다. Archive directory로 지정된 disk로의 I/O 속도가 느린 경우 본 event가 높게 측정될 수 있다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Lgwr Lnw                     | SEC, COUNT | LGWR SYNC 모드로 동작하는 standby가 있을 경우, log writer는 primary와 standby instance에 redo log가 모두 기록되었다는 것을 확인하게 된다. 본 event는 log writer가 standby instance에 redo log가 기록되는 것을 대기한 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Log Flush Commit             | SEC, COUNT | 해당 event는 세션이 commit을 수행하는 작업 중 redo log flush를 요청하고 완료되기 까지 기다리는 시간을 나타낸다. Transaction commit이 완료되기 위해서는 해당 transaction이 남긴 redo log가 모두 redo log file에 flush 되어야 한다. transaction이 수정한 datablock들은 disk에 꼭 flush되지 않아도 commit의 정합성을 지키는 데 문제가 없다. 장애 상황 시 redo log가 flush 된 채로 서버가 down되거나 머신이 종료된 경우, 이 후 부팅 시 DB 서버는 cache recovery와 transaction recovery를 수행한다. cache recovery 시에는 redo log를 다시 반영하여 buffer cache가 down 되기 이전의 상태로 만들어 준다. transaction recovery 시에는 commit에 자체에 대한 redo log도 남기 때문에 commit되지 않은 transaction list를 생성하여 해당 transaction들을 rollback 시켜준다. 이와 같은 동작으로 commit 시 redo log flush만으로 DB 서버의 정합성을 지켜주게 된다. |
| Wait     | We Tsn Sync Commit              | SEC, COUNT | TAC에서 세션이 commit을 수행하는 작업 중 노드 간 tsn sync를 요청하고 완료되기까지 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Wait     | We Log Flush Space              | SEC, COUNT | session이 data block을 수정할 때는 수정 내용을 포함하는 redo log를 생성하고, 이를 data block에 적용한다. 이 과정에서 생성한 redo log는 shared memory상에 위치한 redo log buffer에 기록한다. redo buffer에 생성한 redo log를 기록할 때, redo buffer에 빈 공간이 부족하다면 log writer가 redo log buffer에 기록된 redo log를 flush하여 redo log buffer에 빈 공간을 만들어줄 때까지 대기해야 한다. 본 event는 redo log buffer에 새로운 redo log를 기록하기 위해 log writer가 redo log flush를 통해 redo buffer에 빈 공간을 만들어줄 때까지 대기한 시간을 나타낸다.                                                                                                                                                                                                          |
| Wait     | We Log Flush Req                | SEC, COUNT | Redo buffer에 적재된 redo log 내용을 redo log file로 flush하도록 요청한 경우, redo log flush가 완료될 때까지 대기한 시간을 나타낸다. 사용자가 DDL을 통해 redo log flush를 요청한 경우와 DB server 내부적으로 redo log flush를 요청한 경우를 모두 포함한다. Redo log flush를 명시적으로 요청하지 않더라도, TX commit이 발생하거나, redo buffer에 일정 부분 이상 redo log가 적재되었거나, 일정 시간이 경과한 경우 redo log flush가 이루어진다.                                                                                                                                                                                                                                                                                                             |
| Wait     | We Ckpt Wait                    | SEC, COUNT | 해당 event는 특정 시점까지 DB checkpoint를 요청한 후 checkpoint가 완료될 때까지 대기한 시간을 나타낸다. DB checkpoint란 buffer cache 상에서 특정 시점까지 수정된 내용을 disk에 write하는 작업을 나타낸다. Buffer cache 상에 수정된 data block이 많이 존재하는 경우, checkpoint 과정에서 많은 data block들이 disk로 write될 수 있다. 따라서 checkpoint 과정에서 다량의 disk bandwidth를 점유할 수 있고, DB instance의 성능 또한 저하될 수 있다.                                                                                                                                                                                                                                                                                                        |
| Wait     | We Rt Inflow Wait               | SEC, COUNT | Session 유량제어가 활성화되었을 때, available한 session을 할당받기 위해 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Wait     | We Smr Replay                   | SEC, COUNT | Standby Managed Recovery process(이하 SMR)이 특정 시점까지 replay 완료 하는 것을 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Pe Comm                      | SEC, COUNT | Slave Session이 QC로부터 메시지를 기다리는 시간을 나타낸다. Parallel Execution을 시작하면 전체 query를 관장하는 QC session에서 parallel을 수행할 slave session을 할당받게 된다. 이 때, slave session을 할당 받을 때까지 기다릴 때 해당 event가 발생한다.                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Wait     | We Pe Enq                       | SEC, COUNT | Producer slave session이 consumer slave session의 버퍼를 할당받을 때까지 기다리는 시간을 나타낸다. Parallel Execution을 수행하게 되면, 중간 결과를 만들어내는 producer slave session에서 이 결과를 이용해서 일을 하는 consumer slave session에 해당 결과를 전달하는 과정이 발생한다. 이 과정에서 consumer slave session의 중간 결과 저장 버퍼가 가득 찬 경우, 이 버퍼 공간이 생길 때까지 producer slave session이 대기를 하는 event가 발생한다.                                                                                                                                                                                                                                                                                                        |
| Wait     | We Pe Deq                       | SEC, COUNT | Consumer slave session이 producer slave session이 버퍼를 채울 때까지 기다리는 시간을 나타낸다. Parallel Execution을 수행하게 되면, 중간 결과를 만들어내는 producer slave session에서 이 결과를 이용해서 일을 하는 consumer slave session에 해당 결과를 전달하는 과정이 발생한다. 이 과정에서 consumer slave session의 중간 결과 저장 버퍼가 비어 있는 경우, 중간 결과를 producer slave session이 더 채워줄 때까지 consumer slave session이 대기를 하는 event가 발생한다.                                                                                                                                                                                                                                                                                |
| Wait     | We Acf Mtx Rw                   | SEC, COUNT | Active cluster에서 동기화를 위해 read/write mutex lock을 기다린 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Wait     | We Svc Tx                       | SEC, COUNT | User transaction이 service transaction의 index split 작업이 끝나기를 기다린 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Wait     | We Tx Reco Suspend              | SEC, COUNT | TX recovery 도중 문제가 발생한 상황에서 사용자가 직접 commit force나 rollback force 하기까지 기다린 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Wait     | We Cws Ast                      | SEC, COUNT | 다른 노드로 보낸 wait-lock 요청에 대한 응답을 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Wait     | We Ccc Ast Cr                   | SEC, COUNT | 다른 노드로 보낸 Consistent Read (CR) block 요청에 대한 응답을 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Ccc Ast Cur                  | SEC, COUNT | 다른 노드로 보낸 Current Block 요청에 대한 응답을 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Cr Buf Busy Local            | SEC, COUNT | CR block 요청이 이미 진행 중인 자기 노드의 요청이 끝나기를 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Cr Buf Busy Global           | SEC, COUNT | CR block 요청이 이미 진행 중인 다른 노드의 요청이 끝나기를 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Cur Buf Busy Local           | SEC, COUNT | CUR block 요청이 이미 진행 중인 자기 노드의 다른 세션 요청이 끝나기를 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Wait     | We Cur Buf Busy Global          | SEC, COUNT | CUR block 요청이 이미 진행 중인 다른 노드의 요청이 끝나기를 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Wait     | We Gv Req                       | SEC, COUNT | 다른 노드로부터 새로운 global view 수행 요청을 받기 위해 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Gv Reply                     | SEC, COUNT | 다른 노드로부터 global view 요청에 대한 결과집합을 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Search Space Reply           | SEC, COUNT | 다른 노드로부터 search space 결과를 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Wait     | We Ddl Csr Inval                | SEC, COUNT | deprecated                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Ddl Change Undo Ts           | SEC, COUNT | Undo tablespace를 변경할 때 대기하는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Wait     | We Peq                          | SEC, COUNT | Parallel execution 수행을 위해 큐에서 대기하는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Alert                        | SEC, COUNT | alert을 기다리는 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Wait     | We Wlock Cf                     | SEC, COUNT | Control File을 생성/로드/수정 작업에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Tx                     | SEC, COUNT | 여러 세션에서 동일한 id를 가진 tx가 시작되는 것을 방지하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Wlock St Sgmt                | SEC, COUNT | segment에 extent 할당/해제 작업을 할 때 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Wait     | We Wlock Split                  | SEC, COUNT | 특정 index block에 대한 split 작업을 할 때 획득하는 WLOCK (Index split 기능 개선 전에 사용하던 WLOCK).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Wlock Dml                    | SEC, COUNT | Table이나 연관 Object에 대한 DML/DDL 작업을 할 때 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock User                   | SEC, COUNT | DB User에 대한 profile 변경, 인증 등에서 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Wait     | We Wlock Dd Obj                 | SEC, COUNT | DB Object에 대해 DDL, DD Cache 조회 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Wait     | We Wlock Dd User                | SEC, COUNT | DB User에 대한 DDL, DD Cache 조회 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Wlock Dd Sgmt                | SEC, COUNT | DB 내 segment에 대한 DD Cache 조회 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Wlock Dd Ts                  | SEC, COUNT | DB 내 Tablespace에 대한 DDL이나, Tablespace에 속한 object를 생성 시 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Wait     | We Wlock Dd Ts Ref              | SEC, COUNT | DB tablespace에 속한 object 생성 시 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Wlock Dd Objauth             | SEC, COUNT | DB 내 SQL에서 Object 권한 검사 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Dd Sysauth             | SEC, COUNT | DB 내 SQL에서 System 권한 검사 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Dd Psmir               | SEC, COUNT | DB 내 PSM Unit에 대해 PSM 수행, DD cache 조회 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Wlock Dd Pending Tx          | SEC, COUNT | 여러 세션이 동시에 같은 tx를 commit force 또는 rollback force하는 것을 방지하기 위해 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Wlock Dd Partobj             | SEC, COUNT | Table, Partition, Index DDL 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock Seq Get Nextval        | SEC, COUNT | Sequence에 대해 값 조회나 DDL 등에서 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Wait     | We Wlock Ddl Create Ts          | SEC, COUNT | Tablespace 생성 중 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock Ddl Create Df          | SEC, COUNT | Datafile/logfile add/create/drop/status 변경의 단독 수행을 보호하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Wait     | We Wlock Ddl Create Con         | SEC, COUNT | Constraint 생성 중 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock Xa Bucket              | SEC, COUNT | XA hashtable bucket 접근 시 bucket set 별로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Wlock Xa Glb                 | SEC, COUNT | XA global tx 정보에 접근 시 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock Xa Bch                 | SEC, COUNT | XA branch 정보에 접근 시 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Wait     | We Wlock Xa Vt                  | SEC, COUNT | XA 관련 vt 생성 도중 commit/rollback으로 tx 정보가 삭제되는 것을 막기 위해서 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Wlock Dx                     | SEC, COUNT | Tightly coupled XA branch를 사용하는 session들끼리 SQL 동시 수행을 막기 위해서 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Wait     | We Wlock Ir                     | SEC, COUNT | IR(Instance Recovery)가 진행 중인지 확인하기 위한 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Wlock Temp Granule           | SEC, COUNT | Global temp tablespace에서 자신이 할당받은 공간을 다른 노드에서 사용하지 못하도록 보장하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Wlock Cleanup Dropped Sgmt   | SEC, COUNT | DDL로 인해 Drop된 segment들을 실제로 정리해 줄 때 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Wlock Mv Rfsh                | SEC, COUNT | Mview refresh 시 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock Ddl Recompile          | SEC, COUNT | PSM Recompile 시 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Wlock Asysrecompile          | SEC, COUNT | Alter system recompile all 시 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| Wait     | We Wlock Dbms Pipe List         | SEC, COUNT | DBMS\_PIPE 패키지 사용 시 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Wlock Dp Temp Sgmt           | SEC, COUNT | PDP가 끝나지 않은 상황에서 cleanup 작업이 temp segment를 정리하지 못하도록 보장하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Wait     | We Wlock Standby                | SEC, COUNT | Log Network Reader process가 DB 내에서 단독적으로 수행되기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Wait     | We Wlock Smr                    | SEC, COUNT | Standby Managed Recovery process가 standby TAC multinode 중에 단독적으로 수행되기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Wait     | We Wlock Lnr Reverse Sync       | SEC, COUNT | Standby 강제 역동기화 기능이 단독적으로 수행되기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Auto Coalesce          | SEC, COUNT | Session별로 index auto coalesce를 진행하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Wlock Xtb Timeout Check      | SEC, COUNT | XA 세션의 timeout check 중복 방지를 위한 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Wlock Revalidate Obj         | SEC, COUNT | Invalid DB Object에 대해 revalidation 진행 중 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Wait     | We Wlock Update User Status     | SEC, COUNT | 주기적으로 진행하는 Profile 프로세싱이 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Wait     | We Wlock L1 Local Cache         | SEC, COUNT | 여러 세션이 동시에 같은 segment master에게 L1 분배 요청하는 것을 방지하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Wait     | We Wlock Sc Lru Cache Out       | SEC, COUNT | Shared cache LRU cache out을 진행할 때 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Dbms Lock              | SEC, COUNT | DBMS\_LOCK package를 이용할 때 사용하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Wait     | We Wlock Bitmap Index           | SEC, COUNT | Bitmap index에 key(entry)를 추가하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Bct                    | SEC, COUNT | BCT(Block Change Tracker) 상태 변경을 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Wlock Imcs                   | SEC, COUNT | In-memory column store scan 또는 populate 작업을 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Wait     | We Wlock Imcs Priority Populate | SEC, COUNT | In-memory column store priority populate 작업을 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Wlock Lgwr Status            | SEC, COUNT | Log writer thread 및 check pointer thread의 I/O 작업을 중지/재개 요청한 후 완료되기를 기다리기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Wlock Fb                     | SEC, COUNT | Flashback thread 상태를 변경 시 단독 수행을 보장하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Wait     | We Wlock Rmgr                   | SEC, COUNT | DB 내 RMGR job들의 상황에 따른 독립성을 보호하기 위해 사용되는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Wlock Ts Invalidate          | SEC, COUNT | Tablespace offline 또는 drop 수행 과정에서, global buffer cache invalidation 작업의 중복 수행을 방지하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Wait     | We Wlock Cf Ts                  | SEC, COUNT | Tablespace create/drop 및 Tablespace에 datafile add/rename을 수행할 때 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Wlock Job                    | SEC, COUNT | Job이 여러 wthr에서 중복 수행되는 것을 방지하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Sesskey                | SEC, COUNT | Client로부터 통신 암호화되어 들어온 접속 정보를 복호화할 때 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| Wait     | We Wlock Context Index          | SEC, COUNT | Context index를 sync할 때 내부적으로 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Wait     | We Wlock Rt Standby             | SEC, COUNT | Log Network Writer process가 자신에게 해당되는 standby DB와 redo thread의 동기화를 단독적으로 수행하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Wait     | We Wlock Usgmt                  | SEC, COUNT | Undo segment create, ucache load/reload 등과 같은 undo segment 변경 작업을 수행할 때 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Wait     | We Wlock Rsrc                   | SEC, COUNT | Consumer group 정보 수정을 보호하기 위한 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Wait     | We Wlock Setparam               | SEC, COUNT | Alter system set parameter 사용 시 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Wlock Imt                    | SEC, COUNT | In memory tablespace 초기화 및 in memory tablespace DD 정보를 load 할 때 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| Wait     | We Wlock Expand Rsb             | SEC, COUNT | TAC 환경에서 global buffer cache 관련 memory context(rsb)를 추가로 생성하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| Wait     | We Wlock Expand Lkbset          | SEC, COUNT | TAC 환경에서 data block의 global lock과 관련된 memory context(lkb)를 추가로 생성하기 위해 획득하는 WLOCK                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Jc Buf Disk Read             | SEC, COUNT | DB 블록을 read(단건)한 각 수치를 나타낸다. block disk read time은 disk에서 block을 읽어 buffer cache에 올리기를 기다리는 시간이다. 디스크로부터 버퍼로 블록 1개를 읽어들인다. value는 read 횟수를 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Jc Buf Disk Readm            | SEC, COUNT | DB 블록을 read(여러 건)한 수치를 나타낸다. 디스크로부터 동시에 여러 블록을 버퍼에 읽어들이며 full table scan과 같이 한 번에 연속된 블록을 많이 읽어들이는 경우에 발생한다. value는 disk read를 호출한 횟수이고 size는 disk read된 block의 개수이다. time은 disk read한 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| Wait     | We Jc Ssgmt Read Time           | SEC, COUNT | Sort Segment 영역인 temporary segment를 읽은 횟수, 읽은 extent 개수, 소요한 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Jc Ssgmt Write Time          | SEC, COUNT | Sort Segment 영역인 temporary segment에 쓴 횟수, 사용한 extent 개수, 소요한 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Jc Buf Disk Readm Pga        | SEC, COUNT | PGA에 multi block disk read를 수행하는데 요청한 횟수, 실제 읽은 block 개수, 소요된 시간을 나타낸다. Buffer cache가 아닌 PGA에 multi block disk read를 수행하는 경우에 발생한다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| Wait     | We Jc Dpbuf Wait Write          | SEC, COUNT | Direct Path Load(DPL) 또는 Direct Path Import(DPI) 수행 시 direct path buffer에 loading된 block의 내용을 write하는 통계 정보(횟수 및 write 시간)를 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| Wait     | We Jc Redo Sleep                | SEC, COUNT | Redo resource manager 기능을 사용하는 경우, 유량 제어를 목적으로 redo log 생성 속도와 각 session의 redo log 생성량을 계산하여 session이 redo log를 redo buffer에 쌓을 때 일정 시간 대기하도록 처리한다. 본 event는 이 과정에서 session이 대기한 횟수와 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Wait     | We Jc Fdpool Invl               | SEC, COUNT | Datafile drop 등으로 cache된 관련 fdpool을 invalidate할 때 동일 fdpool을 참조하는 다른 wthr가 해당 fdpool을 release할 때 까지 기다리는 횟수 및 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| Wait     | We Jc Farc Write                | SEC, COUNT | Flashback archive logfile 생성 시 FARC가 디스크에 write 한 횟수, 블록 수, 소요 시간을 나타낸다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| Wait     | We Spin Buf Bucket              | SEC, COUNT | Buffer cache의 hash bucket chain을 보호하는 spinlock과 관련된 통계 정보를 나타낸다. Buffer cache에서는 요청된 block에 빠르게 접근하기 위한 자료구조로 hash bucket table을 사용하며, 각 hash bucket에 chain을 구성하여 hash collision을 해소한다. Block에 접근할 때는 이 hash bucket chain을 탐색하는데, chain 구조를 보호하기 위한 목적으로 본 spinlock을 획득한다. 부하 특성 상 hot block 경합이 심하게 발생하거나, hash bucket table size가 작은 경우 본 spinlock의 경합이 증가할 수 있다.                                                                                                                                                                                                                                                                   |
| Wait     | We Spin Buf Ws                  | SEC, COUNT | Buffer cache의 working set을 보호하는 spinlock과 관련된 통계 정보를 나타낸다. 다수의 session이 동시에 buffer cache에 접근할 때 발생하는 경합을 완화하기 위해, buffer cache에서는 buffer들을 working set이라고 하는 소단위로 나누어 관리한다. 각 working set은 동일한 개수의 buffer를 관리하며, session이 working set에 접근할 때는 working set 내부 관리 구조를 보호하기 위해 본 spinlock을 획득한다. Buffer cache 크기에 비해 working set 개수가 적은 경우, 본 spinlock의 경합이 증가할 수 있다.                                                                                                                                                                                                                                                                    |
| Wait     | We Spin Shp Alloc Lc            | SEC, COUNT | 여러 프로세스에 쓰레드들이 공유하여 쓰고 있는 shared pool allocator의 slave를 위한 spinlock이다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Spin Shp Alloc Dd            | SEC, COUNT | 여러 프로세스에 쓰레드들이 공유하여 쓰고 있는 shared pool allocator의 slave를 위한 spinlock이다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Spin Shp Alloc Misc          | SEC, COUNT | 여러 프로세스에 쓰레드들이 공유하여 쓰고 있는 shared pool allocator의 slave를 위한 spinlock이다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Spin Shp Alloc Slab          | SEC, COUNT | 여러 프로세스에 쓰레드들이 공유하여 쓰고 있는 shared pool allocator의 slave를 위한 spinlock이다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| Wait     | We Spin Shp Alloc Super         | SEC, COUNT | 여러 프로세스에 쓰레드들이 공유하여 쓰고 있는 shared pool allocator를 위한 spinlock이다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| Wait     | We Spin Alloc Lru               | SEC, COUNT | Shared pool의 recreatable chunk 중에 재사용이 가능한 recreatable chunk를 모아둔 LRU list를 보호하기 위한 spinlock이다.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |

### SQL Indicators

| Category | Indicator     | Unit | Description                       |
| -------- | ------------- | ---- | --------------------------------- |
| SQL      | Response Time | SEC  | 수행에 일정 시간 이상 소요된 SQL Trace의 수행 시간 |
