> ## Documentation Index > Fetch the complete documentation index at: https://otel.fyi/llms.txt > Use this file to discover all available pages before exploring further. # Oracledb > OpenTelemetry receiver for Oracledb # Oracledb Receiver ![Status](https://img.shields.io/badge/status-alpha-red) **Available in:** `contrib` **Maintainers:** [@dmitryax](https://github.com/dmitryax), [@crobert-1](https://github.com/crobert-1), [@atoulme](https://github.com/atoulme) **Source:** [opentelemetry-collector-contrib](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/oracledbreceiver) ## Supported Telemetry ![Logs](https://img.shields.io/badge/logs-development-blue) ![Metrics](https://img.shields.io/badge/metrics-alpha-green) ## Overview ## Getting Started To use the Oracle DB receiver you must define how to connect to your DB. This can be done in two ways, defined in the [Primary](#primary-configuration-option) and [Secondary](#secondary-configuration-option) configuration option sections. Defining one of the two configurations is required. If both are defined, the primary option will be used. ### Primary Configuration Option Required options: * `datasource`: Oracle database connection string. Special characters must be encoded. Refer to [Oracle Go Driver go\_ora documentation](https://github.com/sijms/go-ora) for full connection string options. Example: ```yaml theme={null} receivers: oracledb: datasource: "oracle://otel:password@localhost:51521/XE" ``` ### Secondary Configuration Option Required options: * `endpoint`: Endpoint used to connect to the Oracle DB server. Must be in the format of `host:port` * `password`: Password for the Oracle DB connection. Special characters are allowed. * `service`: Oracle DB service that the receiver should connect to. * `username`: Username for the Oracle DB connection. Example: ```yaml theme={null} receivers: oracledb: endpoint: localhost:51521 password: p@sswo%d service: XE username: otel ``` ### Optional Configuration Options * `collection_interval` (default = `10s`): The interval at which metrics should be emitted by this receiver. * `initial_delay` (default = `1s`): The initial time period this receiver waits before starting. * `timeout` (default = `0`): Timeout for each Oracle DB request. Disabled by default. ## Permissions ### Instance detection These grants are required to populate the `oracle.db.version`, `oracle.db.role`, `oracle.db.open_mode`, and `oracle.db.pdb` resource attributes. Detection is best-effort; failures are logged at warn level and the receiver continues. ```sql theme={null} GRANT SELECT ON V_$INSTANCE TO ; GRANT SELECT ON V_$DATABASE TO ; ``` > **Note:** `sys_context('USERENV', ...)` queries against `DUAL` require no > additional grant and are available to all database users. ### Hosting type detection (Oracle >=19c only) These grants are required to populate the `oracle.db.hosting_type` resource attribute. Only applies to Oracle 19c and later. Detection is best-effort; failures are logged at warn level and the receiver continues. ```sql theme={null} GRANT SELECT ON V_$DATAFILE TO ; GRANT SELECT ON V_$PDBS TO ; -- OCI detection, connected to PDB only GRANT SELECT ON CDB_SERVICES TO ; -- OCI confirmation, connected to PDB only ``` ### Metrics collection Depending on which metrics you collect, you will need to assign these permissions to the database user: ```sql theme={null} GRANT SELECT ON V_$SESSION TO ; GRANT SELECT ON V_$SYSSTAT TO ; GRANT SELECT ON V_$RESOURCE_LIMIT TO ; GRANT SELECT ON DBA_TABLESPACES TO ; GRANT SELECT ON DBA_DATA_FILES TO ; GRANT SELECT ON DBA_TABLESPACE_USAGE_METRICS TO ; ``` ### Events collection These grants are required for the `db.server.query_sample`, `db.server.top_query`, and `db.server.session.wait_sample` events. ```sql theme={null} GRANT SELECT ON V_$SQL TO ; GRANT SELECT ON V_$SQL_PLAN_STATISTICS_ALL TO ; GRANT SELECT ON V_$SESSION TO ; GRANT SELECT ON V_$SESSION_EVENT TO ; GRANT SELECT ON V_$LOCK TO ; GRANT SELECT ON V_$CONTAINERS TO ; GRANT SELECT ON DBA_OBJECTS TO ; GRANT SELECT ON DBA_PROCEDURES TO ; ``` > \[!NOTE] > In the SQL query plan details, the LAST\_\*, OUTPUT\_ROWS, and STARTS columns are populated only when Oracle is configured to collect execution plan statistics (for example, STATISTICS\_LEVEL=ALL or the GATHER\_PLAN\_STATISTICS hint). Otherwise, these fields will be NULL or empty. Configuring this Oracle instrumentation may introduce additional runtime overhead. Enable it only if you need these runtime execution statistics for query performance analysis. ```sql theme={null} ALTER SYSTEM SET statistics_level = ALL; ``` ## Enabling metrics. See [documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/oracledbreceiver/documentation.md). You can enable or disable selective metrics. Example: ```yaml theme={null} receivers: oracledb: datasource: "oracle://otel:password@localhost:51521/XE" metrics: oracledb.query.cpu_time: enabled: false oracledb.query.physical_read_requests: enabled: true ``` ## Enabling events. The following is a generic configuration that can be used for the default logs and metrics scraped by the Oracle DB receiver. ```yaml theme={null} receivers: oracledb: collection_interval: 10s # interval for overall collection datasource: "oracle://otel:password@localhost:51521/XE" events: db.server.query_sample: enabled: true db.server.top_query: enabled: true db.server.session.wait_sample: enabled: true top_query_collection: # this collection exports the most expensive queries as logs max_query_sample_count: 1000 # maximum number of samples collected from db to filter the top N top_query_count: 200 # The maximum number of queries (N) for which the metrics would be reported collection_interval: 60s # collection interval for top query collection specifically allowed_comment_keys: [application] # keys to extract from leading SQL comments (see SQL Comment Extraction below) query_sample_collection: # this collection exports the currently (relate to the query time) executing queries as logs max_rows_per_query: 100 # the maximum number of samples to bre reported. allowed_comment_keys: [application] # keys to extract from leading SQL comments (see SQL Comment Extraction below) session_wait_event_collection: # this collection exports per-session wait event statistics from v$session_event as logs max_rows_per_query: 100 # the maximum number of session wait event rows to be reported ``` ## SQL Comment Extraction When the `db.server.query_sample` and/or `db.server.top_query` events are enabled, the receiver can extract key-value pairs from leading SQL block comments (`/* key=value */`) and emit them as the `db.query.comment_tags` attribute on the corresponding logs. This behavior is controlled by the `allowed_comment_keys` option, which can be set independently under `top_query_collection` and `query_sample_collection`: * `allowed_comment_keys` (default = `[]`): A list of comment keys to extract. For each enabled collection, only keys present in this allowlist are extracted from the leading SQL comment and included (as comma-separated `key=value` pairs) in the `db.query.comment_tags` attribute. Extraction is disabled unless explicitly configured: * When `allowed_comment_keys` is empty or unset, no comments are extracted. * Only keys included in the allowlist are emitted; all other comment keys are ignored. * Only leading block comments are parsed; comments elsewhere in the query are ignored. Example: ```yaml theme={null} receivers: oracledb: datasource: "oracle://otel:password@localhost:51521/XE" events: db.server.query_sample: enabled: true db.server.top_query: enabled: true top_query_collection: allowed_comment_keys: [application, team] query_sample_collection: allowed_comment_keys: [application, team] ``` Given a query such as `/* application=exampleApp,team=payments */ SELECT * FROM users`, the emitted log record will include `db.query.comment_tags` set to `application=exampleApp,team=payments`. When multiple keys are extracted, they are emitted as a comma-separated list of `key=value` pairs. See [documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/oracledbreceiver/documentation.md) for details on the `db.query.comment_tags` attribute. ## Metrics | Metric Name | Description | Unit | Type | Attributes | | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- | ------- | -------------------------------------- | | ❌ `oracledb.buffer.inspected` | Number of buffers inspected from the end of the LRU queue while a process searched for a reusable buffer, grouped by buffer state. | \{buffer} | Counter | oracledb.buffer.state | | ❌ `oracledb.buffer.requests` | Number of times a reusable or free buffer was requested to create or load a block. | \{request} | Counter | | | ❌ `oracledb.buffer_cache.block.changes` | Number of changes that were part of an update or delete operation made to blocks in the buffer cache. | \{change} | Counter | | | ❌ `oracledb.buffer_cache.block.gets` | Number of current-mode block gets satisfied from the buffer cache. Distinct from oracledb.db\_block\_gets, which counts all current-mode block gets requested regardless of where they are satisfied. | \{get} | Counter | | | ❌ `oracledb.buffer_cache.utilization` | Fraction of logical reads served from the buffer cache without physical I/O, as computed by Oracle V\$SYSMETRIC (% (LogRead - PhyRead)/LogRead). | % | Gauge | | | ❌ `oracledb.call.count` | Total count of calls issued to the database. | \{call} | Counter | oracledb.call.type | | ❌ `oracledb.call.recursive.cpu.time` | Total CPU time spent on recursive (internal) calls. | s | Counter | | | ❌ `oracledb.checkpoint.buffers` | Number of buffers written by the Database Writer (DBWR) for checkpoints. | \{buffer} | Counter | | | ❌ `oracledb.checkpoint.completed` | Number of checkpoints completed by the Database Writer (DBWR). | \{checkpoint} | Counter | | | ❌ `oracledb.consistent_gets` | Number of times a consistent read was requested for a block from the buffer cache. | \{gets} | Counter | | | ✅ `oracledb.cpu_time` | Cumulative CPU time, in seconds | s | Counter | | | ❌ `oracledb.cursor.cache.hits` | Total count of session cursor cache hits, where an existing cached cursor is reused to avoid a soft parse. | \{hit} | Counter | | | ❌ `oracledb.cursor.cache.size` | Number of cursors currently held in the session cursor cache. | \{cursor} | Gauge | | | ❌ `oracledb.cursor.open` | Number of currently open cursors in the Oracle instance. | \{cursor} | Gauge | | | ❌ `oracledb.data_dictionary.hit_ratio` | Data dictionary cache hit ratio from v\$rowcache. | % | Gauge | | | ❌ `oracledb.database.cpu.utilization` | Fraction of total database time spent on CPU, as computed by Oracle V\$SYSMETRIC (% Cpu/DB\_Time). | % | Gauge | | | ❌ `oracledb.database.wait.utilization` | Fraction of total database time spent waiting on I/O, locks, or latches, as computed by Oracle V\$SYSMETRIC (% Wait/DB\_Time). | % | Gauge | | | ❌ `oracledb.db.time` | Total wall-clock time spent in database calls. | s | Counter | oracledb.session.type | | ❌ `oracledb.db_block_gets` | Number of times a current block was requested from the buffer cache. | \{gets} | Counter | | | ❌ `oracledb.ddl_statements_parallelized` | Number of DDL statements that were executed in parallel | \{statements} | Counter | | | ✅ `oracledb.dml_locks.limit` | Maximum limit of active DML (Data Manipulation Language) locks, -1 if unlimited. | \{locks} | Gauge | | | ✅ `oracledb.dml_locks.usage` | Current count of active DML (Data Manipulation Language) locks. | \{locks} | Gauge | | | ❌ `oracledb.dml_statements_parallelized` | Number of DML statements that were executed in parallel | \{statements} | Counter | | | ❌ `oracledb.enqueue.operations` | Total count of enqueue (lock) operations. | \{operation} | Counter | oracledb.enqueue.type | | ✅ `oracledb.enqueue_deadlocks` | Total number of deadlocks between table or row locks in different sessions. | \{deadlocks} | Counter | | | ✅ `oracledb.enqueue_locks.limit` | Maximum limit of active enqueue locks, -1 if unlimited. | \{locks} | Gauge | | | ✅ `oracledb.enqueue_locks.usage` | Current count of active enqueue locks. | \{locks} | Gauge | | | ✅ `oracledb.enqueue_resources.limit` | Maximum limit of active enqueue resources, -1 if unlimited. | \{resources} | Gauge | | | ✅ `oracledb.enqueue_resources.usage` | Current count of active enqueue resources. | \{resources} | Gauge | | | ✅ `oracledb.exchange_deadlocks` | Number of times that a process detected a potential deadlock when exchanging two buffers and raised an internal, restartable error. Index scans are the only operations that perform exchanges. | \{deadlocks} | Counter | | | ❌ `oracledb.execution.utilization` | Fraction of executions that did not require a parse, as computed by Oracle V\$SYSMETRIC (% (ExecWOParse/TotalExec)). High values indicate good cursor reuse. | % | Gauge | oracledb.parse.type | | ✅ `oracledb.executions` | Total number of calls (user and recursive) that executed SQL statements | \{executions} | Counter | | | ✅ `oracledb.hard_parses` | Number of hard parses | \{parses} | Counter | | | ❌ `oracledb.host.cpu.utilization` | Fraction of host CPU time in use, as computed by Oracle V\$SYSMETRIC (% Busy/(Idle+Busy)). | % | Gauge | | | ❌ `oracledb.library_cache.utilization` | Fraction of library cache pin requests that found the object already cached, as computed by Oracle V\$SYSMETRIC (% Hits/Pins). | % | Gauge | | | ❌ `oracledb.lob.operations` | Total count of LOB (large object) I/O operations. | \{operation} | Counter | disk.io.direction | | ✅ `oracledb.logical_reads` | Number of logical reads | \{reads} | Counter | | | ❌ `oracledb.logons` | Number of logon operations | \{operation} | Counter | | | ❌ `oracledb.parallel_operations_downgraded_1_to_25_pct` | Number of times parallel execution was requested and the degree of parallelism was reduced down to 1-25% because of insufficient parallel execution servers | \{executions} | Counter | | | ❌ `oracledb.parallel_operations_downgraded_25_to_50_pct` | Number of times parallel execution was requested and the degree of parallelism was reduced down to 25-50% because of insufficient parallel execution servers | \{executions} | Counter | | | ❌ `oracledb.parallel_operations_downgraded_50_to_75_pct` | Number of times parallel execution was requested and the degree of parallelism was reduced down to 50-75% because of insufficient parallel execution servers | \{executions} | Counter | | | ❌ `oracledb.parallel_operations_downgraded_75_to_99_pct` | Number of times parallel execution was requested and the degree of parallelism was reduced down to 75-99% because of insufficient parallel execution servers | \{executions} | Counter | | | ❌ `oracledb.parallel_operations_downgraded_to_serial` | Number of times parallel execution was requested but execution was serial because of insufficient parallel execution servers | \{executions} | Counter | | | ❌ `oracledb.parallel_operations_not_downgraded` | Number of times parallel execution was executed at the requested degree of parallelism | \{executions} | Counter | | | ❌ `oracledb.parse.cpu.time` | Total CPU time spent on SQL parsing. | s | Counter | | | ❌ `oracledb.parse.elapsed.time` | Total wall-clock time spent on SQL parsing. | s | Counter | | | ❌ `oracledb.parse.rate` | Rate of parse operations per second broken down by result, as computed by Oracle V\$SYSMETRIC (e.g., Parse Failure Count Per Sec). | \{parses}/s | Gauge | oracledb.parse.result | | ❌ `oracledb.parse.utilization` | Fraction of parse calls that were soft parses, as computed by Oracle V\$SYSMETRIC (% SoftParses/TotalParses). High values indicate good cursor reuse. | % | Gauge | | | ✅ `oracledb.parse_calls` | Total number of parse calls. | \{parses} | Counter | | | ✅ `oracledb.pga_memory` | Session PGA (Program Global Area) memory | By | Counter | | | ❌ `oracledb.physical_io.cache_writes` | Number of physical writes from the buffer cache to disk by DBWR. Sourced from v\$sysstat name physical writes from cache. | \{writes} | Counter | | | ❌ `oracledb.physical_io.requests` | Number of physical I/O requests issued to storage. Sourced from v\$sysstat names physical read/write total IO requests (disk.io.block\_size=all) and physical read/write total multi block requests (disk.io.block\_size=multi). | \{requests} | Counter | disk.io.direction, disk.io.block\_size | | ❌ `oracledb.physical_io.transferred` | Total physical I/O bytes transferred between Oracle and storage. Sums across all data files. Sourced from v\$sysstat names physical read/write bytes (disk.io.type=buffered) and physical read/write total bytes (disk.io.type=total). | By | Counter | disk.io.direction, disk.io.type | | ❌ `oracledb.physical_read_io_requests` | Number of read requests for application activity | \{requests} | Counter | | | ✅ `oracledb.physical_reads` | Number of physical reads | \{reads} | Counter | | | ❌ `oracledb.physical_reads_direct` | Number of reads directly from disk, bypassing the buffer cache | \{reads} | Counter | | | ❌ `oracledb.physical_write_io_requests` | Number of write requests for application activity | \{requests} | Counter | | | ❌ `oracledb.physical_writes` | Number of physical writes | \{writes} | Counter | | | ❌ `oracledb.physical_writes_direct` | Number of writes directly to disk, bypassing the buffer cache | \{writes} | Counter | | | ✅ `oracledb.processes.limit` | Maximum limit of active processes, -1 if unlimited. | \{processes} | Gauge | | | ✅ `oracledb.processes.usage` | Current count of active processes. | \{processes} | Gauge | | | ❌ `oracledb.queries_parallelized` | Number of SELECT statements executed in parallel | \{queries} | Counter | | | ❌ `oracledb.recycle_bin.limit` | Total size of the recycle bin. | By | Gauge | | | ❌ `oracledb.redo.blocks` | Number of redo blocks moved between the redo log and storage. | \{block} | Counter | disk.io.direction | | ❌ `oracledb.redo.operations` | Number of redo I/O operations. | \{operation} | Counter | disk.io.direction | | ❌ `oracledb.redo.requests` | Number of times a process requested space in the redo log buffer and had to wait. | \{request} | Counter | oracledb.redo.request.type | | ❌ `oracledb.redo.retries` | Number of times a process waited and retried to allocate space in the redo buffer. | \{retry} | Counter | oracledb.redo.retry.type | | ❌ `oracledb.redo.size` | Amount of redo generated. | By | Counter | | | ❌ `oracledb.redo.time` | Time spent in each phase of the redo pipeline. | s | Counter | oracledb.redo.type | | ❌ `oracledb.redo_allocation.utilization` | Fraction of redo allocations that succeeded without space contention, as computed by Oracle V\$SYSMETRIC (% (#Redo - RedoSpaceReq)/#Redo). | % | Gauge | | | ❌ `oracledb.scan.count` | Total count of scan operations. | \{operation} | Counter | oracledb.scan.type, oracledb.scan.mode | | ❌ `oracledb.scan.table.rows` | Total number of rows returned by full-table scans. | \{row} | Counter | | | ✅ `oracledb.sessions.limit` | Maximum limit of active sessions, -1 if unlimited. | \{sessions} | Gauge | | | ✅ `oracledb.sessions.usage` | Count of active sessions. | \{sessions} | Gauge | session\_type, session\_status | | ❌ `oracledb.shared_pool.utilization` | Fraction of the shared pool that is currently free, as computed by Oracle V\$SYSMETRIC (% Free/Total). Low values indicate shared pool pressure. | % | Gauge | | | ❌ `oracledb.sort.operations` | Total count of sort operations. | \{operation} | Counter | oracledb.sort.type | | ❌ `oracledb.sort.ratio` | Fraction of sorts performed in memory vs disk, as computed by Oracle V\$SYSMETRIC (% MemSort/(MemSort + DiskSort)). Low values indicate PGA memory pressure. | 1 | Gauge | oracledb.sort.type | | ❌ `oracledb.sort.rows` | Total number of rows sorted across all sort operations. | \{row} | Counter | | | ❌ `oracledb.sql_service.response.duration` | Average SQL service response time in seconds, converted from centiseconds as reported by Oracle V\$SYSMETRIC (CentiSeconds Per Call). | s | Gauge | | | ❌ `oracledb.sqlnet.io.transferred` | Bytes transferred via SQL*Net between Oracle and clients/dblinks. Sourced from v\$sysstat names bytes received/sent via SQL*Net from/to client/dblink. | By | Counter | network.io.direction, destination.type | | ❌ `oracledb.storage.usage` | Used database storage size from dba\_data\_files and dba\_free\_space. | By | Gauge | | | ❌ `oracledb.storage.utilization` | Fraction of allocated database storage that is used. | 1 | Gauge | | | ✅ `oracledb.tablespace_size.limit` | Maximum size of tablespace in bytes, -1 if unlimited. | By | Gauge | tablespace\_name | | ✅ `oracledb.tablespace_size.usage` | Used tablespace in bytes. | By | Gauge | tablespace\_name | | ✅ `oracledb.transactions.limit` | Maximum limit of active transactions, -1 if unlimited. | \{transactions} | Gauge | | | ✅ `oracledb.transactions.usage` | Current count of active transactions. | \{transactions} | Gauge | | | ✅ `oracledb.user_commits` | Number of user commits. When a user commits a transaction, the redo generated that reflects the changes made to database blocks must be written to disk. Commits often represent the closest thing to a user transaction rate. | \{commits} | Counter | | | ✅ `oracledb.user_rollbacks` | Number of times users manually issue the ROLLBACK statement or an error occurs during a user's transactions | 1 | Counter | | ## Attributes | Attribute Name | Description | Type | Values | | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ---------------------------------------------------------- | | `client.address` | Hostname or address of the client. | string | | | `client.port` | TCP port used by the client. | int | | | `db.namespace` | The database name. | string | | | `db.query.comment_tags` | Filtered SQL query comments extracted from leading block comments. Contains comma-separated key=value pairs for keys specified in allowed\_comment\_keys configuration. Used for correlation with APM traces. | string | | | `db.query.text` | The text of the database query being executed. | string | | | `db.server.name` | The name of the server hosting the database. | string | | | `db.system.name` | The database management system (DBMS) product as identified by the client instrumentation. | string | | | `destination.type` | Type of the SQL\*Net destination endpoint (client application or remote database link). | string | `client`, `dblink` | | `disk.io.block_size` | Multi-block vs single-block (all) I/O request grouping. | string | `all`, `multi` | | `disk.io.direction` | Direction of the storage I/O operation. | string | `read`, `write` | | `disk.io.type` | Whether the I/O bytes are buffered (cache-mediated) or total (raw transfer count). | string | `buffered`, `total` | | `network.io.direction` | Direction of the SQL\*Net network transfer. | string | `receive`, `transmit` | | `network.peer.address` | IP address of the peer client. | string | | | `network.peer.port` | TCP port used by the peer client. | int | | | `oracle.db.service` | The Oracle service name associated with the database connection. | string | | | `oracledb.application_wait_time` | The total time (in seconds) a query spent waiting on the application before it could proceed with execution (reporting delta). | double | | | `oracledb.blocking.blocker.root_sid` | The session ID (SID) of the root/head blocker at the top of the blocking chain. Empty string when there is no blocking. | string | | | `oracledb.blocking.blocker.sid` | The session ID (SID) of the immediate blocker of this session. Empty string when the session is not blocked. | string | | | `oracledb.blocking.blocker.state` | The status of the blocking session relationship (e.g. VALID, NOT IN WAIT, GLOBAL, NO HOLDER, UNKNOWN). | string | | | `oracledb.blocking.lock.mode` | The lock mode being requested by the blocked session (e.g., ROW SHARE, ROW EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE, EXCLUSIVE). Empty when not waiting on a lock. | string | | | `oracledb.blocking.lock.type` | The type of enqueue lock the session is waiting on, extracted from the wait event (e.g., TX for row lock, TM for table lock). Empty when not waiting on a lock. | string | | | `oracledb.blocking.object.name` | The name of the database object the session is waiting to lock. Empty when no object lock wait is active. | string | | | `oracledb.blocking.object.owner` | The owner (schema) of the database object the session is waiting to lock. Empty when no object lock wait is active. | string | | | `oracledb.blocking.start_time` | Estimated UTC timestamp of when the blocking wait began, derived from SYSDATE - SECONDS\_IN\_WAIT. RFC3339 format. | string | | | `oracledb.blocking.wait_duration` | The number of seconds this session has been waiting for the current wait event. | int | | | `oracledb.buffer.state` | The state of a buffer encountered while inspecting the LRU queue for a reusable buffer (free = a reusable buffer that was skipped; dirty = a dirty buffer found). | string | `free`, `dirty` | | `oracledb.buffer_gets` | Number of logical reads (i.e., buffer cache accesses) performed by a query (reporting delta). | int | | | `oracledb.call.type` | Type of call reported by Oracle. | string | `recursive`, `user` | | `oracledb.child_address` | Address of the child cursor. | string | | | `oracledb.child_number` | The child number of the query. | string | | | `oracledb.cluster_wait_time` | Total time (in seconds) that a query waited due to Oracle Real Application Clusters (RAC) coordination (reporting delta). | double | | | `oracledb.command_type` | Command type of the query. | int | | | `oracledb.concurrency_wait_time` | Total time (in seconds) a query spent waiting on concurrency-related events (reporting delta). | double | | | `oracledb.cpu_time` | Total time (in seconds) that the CPU spent actively processing a query, excluding time spent waiting (reporting delta). | double | | | `oracledb.direct_reads` | The number of direct path reads performed by a query — i.e., data blocks read directly from disk into the session’s memory (reporting delta). | int | | | `oracledb.direct_writes` | The number of direct path write operations, where data is written directly to disk from user memory (reporting delta). | int | | | `oracledb.disk_reads` | The number of physical reads a query performs — that is, the number of data blocks read from disk (reporting delta). | int | | | `oracledb.duration_sec` | Total time taken by a database query to execute. | double | | | `oracledb.elapsed_time` | The total time (in seconds) taken by a query from start to finish, including CPU time and all types of waits (reporting delta). | double | | | `oracledb.enqueue.type` | Type of enqueue (lock) operation reported by Oracle. | string | `conversions`, `releases`, `requests`, `timeouts`, `waits` | | `oracledb.event` | The specific wait event that a query or session is currently experiencing. | string | | | `oracledb.executions` | The number of times a specific SQL query has been executed (reporting delta). | int | | | `oracledb.module` | Logical module name of the client application that initiated a query or session. | string | | | `oracledb.osuser` | Name of the operating system user that initiated or is running the Oracle database session. | string | | | `oracledb.parse.result` | Result of a parse operation (e.g., failure). | string | `failure` | | `oracledb.parse.type` | Type of parse operation (e.g., soft). | string | `soft` | | `oracledb.physical_read_bytes` | The total number of bytes read from disk by a query (reporting delta). | int | | | `oracledb.physical_read_requests` | The number of physical I/O read operations performed by a query (reporting delta). | int | | | `oracledb.physical_write_bytes` | The total number of bytes written to disk by a query (reporting delta). | int | | | `oracledb.physical_write_requests` | The number of times a query requested to write data to disk (reporting delta). | int | | | `oracledb.plan.first_load` | Time at which the plan was first loaded into the library cache, in the server's local timezone. Format: YYYY-MM-DD/HH:MM:SS | string | | | `oracledb.plan.last_load` | Plan load time in the server's local timezone. Format: YYYY-MM-DD/HH:MM:SS | string | | | `oracledb.plan_hash_value` | Binary hash value calculated on the query execution plan and used to identify similar query execution plans, reported in the HEX format. | string | | | `oracledb.procedure_execution_count` | The number of times the stored procedure has been executed, derived from the minimum statement execution count across all statements in the procedure (reporting delta). Please note, this is best effort and may not be accurate in some scenarios. Use with caution. | int | | | `oracledb.procedure_id` | The identifier of the stored procedure or function being executed by the query. | int | | | `oracledb.procedure_name` | Name of the database object that a query is accessing. | string | | | `oracledb.procedure_type` | Type of the database object that a query is accessing. | string | | | `oracledb.process` | The operating system process ID (PID) associated with a session. | string | | | `oracledb.program` | Name of the client program or tool that initiated the Oracle database session. | string | | | `oracledb.query.started` | The timestamp when the SQL statement started execution, in ISO 8601 format (UTC). | string | | | `oracledb.query.wait_time` | The wait time in seconds. If the session is currently waiting, the value is the time spent waiting in the current wait. Returns 0 if the session is not currently waiting. | double | | | `oracledb.query_plan` | The query execution plan used by the SQL Server. | string | | | `oracledb.redo.request.type` | The type of redo log buffer space request. | string | `log_space` | | `oracledb.redo.retry.type` | The type of redo buffer allocation retry. | string | `buffer_allocation` | | `oracledb.redo.type` | The phase of the redo pipeline that a redo time measurement is attributed to. | string | `write`, `log_space_wait`, `sync` | | `oracledb.rows_processed` | The total number of rows that a query has read, returned, or affected during its execution (reporting delta). | int | | | `oracledb.scan.mode` | Execution mode of the scan reported by Oracle. | string | `direct_read`, `full`, `long_tables`, `rowid_ranges` | | `oracledb.scan.type` | Type of scan operation reported by Oracle. | string | `index_fast_full`, `table` | | `oracledb.schemaname` | Oracle schema under which SQL statements are being executed | string | | | `oracledb.serial` | Serial number associated with a session. | string | | | `oracledb.session.duration` | The total time in seconds that the session has been connected. | double | | | `oracledb.session.started` | The timestamp when the session logged on, in ISO 8601 format (UTC). | string | | | `oracledb.session.type` | Class of session the database time is attributed to. | string | `foreground` | | `oracledb.sid` | ID of the Oracle Server session. | string | | | `oracledb.sort.type` | Type of sort operation (e.g., memory, disk). | string | `disk`, `memory` | | `oracledb.sql_id` | The SQL ID of the query. | string | | | `oracledb.state` | Current state of the query or the session executing it. | string | | | `oracledb.status` | Execution state or result of a database query or session. | string | | | `oracledb.user_io_wait_time` | The total time (in seconds) a query spent waiting for user I/O operations—such as reading or writing data to disk or network file systems (reporting delta). | double | | | `oracledb.wait.count` | Total number of waits for the wait event across all sessions. | int | | | `oracledb.wait.duration` | Total time waited in seconds for the wait event. | double | | | `oracledb.wait_class` | The category of wait events a query or session is currently experiencing in Oracle Database. | string | | | `session_status` | Session status | string | | | `session_type` | Session type | string | | | `tablespace_name` | Tablespace name | string | | | `user.name` | Database user name under which a session is connected to | string | | ## Resource Attributes | Attribute Name | Description | Type | Enabled | | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | ------- | | `host.name` | The host name of Oracle Server | string | ✅ | | `oracle.db.hosting_type` | The hosting environment of the Oracle instance. One of "self-managed", "rds", or "oci". | string | ✅ | | `oracle.db.open_mode` | The open mode of the Oracle database (e.g. "READ WRITE", "READ ONLY", "MOUNTED"). | string | ✅ | | `oracle.db.pdb` | The pluggable database (PDB) name associated with the connection. | string | ✅ | | `oracle.db.role` | The database role of the Oracle instance (e.g. "PRIMARY", "PHYSICAL STANDBY"). | string | ✅ | | `oracle.db.version` | The Oracle Database version string. | string | ✅ | | `oracledb.instance.name` | The name of the instance that data is coming from. | string | ✅ | | `service.instance.id` | A unique identifier of the Oracle DB instance in the format host:port/serviceName. (defaults to 'unknown:1521', in case of error in generating this value) | string | ✅ | | `service.name` | Logical name of the service. When enabled, defaults to unknown\_service:oracle. | string | ❌ | | `service.namespace` | Logical namespace for the service (for example team or environment). When enabled, defaults to an empty string until set via configuration. | string | ❌ | ## Configuration ### Example Configuration ```yaml theme={null} oracledb: # driver name: oracle endpoint: localhost:51521 password: password service: XE username: otel # Refer to Oracle Go Driver go_ora documentation for full connection string options datasource: "oracle://otel:password@localhost:51521/XE" top_query_collection: max_query_sample_count: 222 top_query_count: 200 metrics: oracledb.exchange_deadlocks: enabled: false oracledb.tablespace_size.usage: enabled: false events: db.server.top_query: enabled: true db.server.query_sample: enabled: true ``` *** *Last generated: 2026-07-06*