From a10373be1ea12a8c8a0c16c549e63fba03bd073f Mon Sep 17 00:00:00 2001 From: vasavi-r Date: Mon, 18 May 2026 16:35:52 +0530 Subject: [PATCH 1/3] OCI observability integration doc --- .../oci-observability-integration/_meta.json | 5 + .../oci-observability-integration/index.mdx | 26 ++ ...cledb-query-monitoring-instrumentation.mdx | 299 ++++++++++++++++++ 3 files changed, 330 insertions(+) create mode 100644 src/content/docs/docs/oci-observability-integration/_meta.json create mode 100644 src/content/docs/docs/oci-observability-integration/index.mdx create mode 100644 src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx diff --git a/src/content/docs/docs/oci-observability-integration/_meta.json b/src/content/docs/docs/oci-observability-integration/_meta.json new file mode 100644 index 00000000..3940accb --- /dev/null +++ b/src/content/docs/docs/oci-observability-integration/_meta.json @@ -0,0 +1,5 @@ +{ + "label": "OCI Observability Integration", + "order": 8, + "collapsed": true +} diff --git a/src/content/docs/docs/oci-observability-integration/index.mdx b/src/content/docs/docs/oci-observability-integration/index.mdx new file mode 100644 index 00000000..7735ab0b --- /dev/null +++ b/src/content/docs/docs/oci-observability-integration/index.mdx @@ -0,0 +1,26 @@ +--- +title: "OCI Observability Integration" +description: "Monitor OCI-hosted Oracle Database workloads with KloudMate using OracleDB telemetry collection for query, session, and resource visibility." +sidebar: + label: "Overview" + order: 1 +--- + +KloudMate's OCI observability integration helps you monitor Oracle Database workloads running on Oracle Cloud Infrastructure with centralized telemetry collection and analysis. By connecting your OCI-hosted OracleDB environment through the KloudMate Agent, you can capture database metrics, sessions, and operational signals in one place. + +## How it Works + +KloudMate uses the KloudMate Agent, powered by OpenTelemetry, to connect to your Oracle Database instance with a dedicated monitoring user. The agent collects OracleDB telemetry from the configured receivers and forwards it securely to KloudMate, where you can explore metrics, investigate query behavior, and build dashboards and alerts. + +## Key Capabilities + +- **OracleDB Telemetry Collection**: Collect database metrics and operational signals from Oracle Database instances hosted on OCI. +- **Query and Session Visibility**: Monitor SQL activity and session-related telemetry through OracleDB receiver configuration. +- **Centralized Analysis**: Send OracleDB data into KloudMate for dashboards, alerting, and troubleshooting workflows. +- **Flexible Agent-Based Setup**: Configure the integration through the KloudMate Agent running alongside your OracleDB environment. + +## Available Guides + +Use the following guide to configure OracleDB monitoring for OCI-hosted deployments: + +- **[OracleDB Query Monitoring Instrumentation](./oracledb-query-monitoring-instrumentation/)**: Configure the KloudMate Agent and OracleDB receivers to collect SQL query, session, and resource telemetry. diff --git a/src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx b/src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx new file mode 100644 index 00000000..17ec6915 --- /dev/null +++ b/src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx @@ -0,0 +1,299 @@ +--- +title: "OracleDB Query Monitoring Instrumentation" +description: "Configure OracleDB SQL query and session receivers in the KloudMate Agent to monitor OCI-hosted Oracle Database workloads." +sidebar: + label: "OracleDB Query Monitoring Instrumentation" + order: 2 +--- + +Oracle Database is foundational for many enterprise applications, and robust monitoring is essential for maintaining performance and reliability. KloudMate provides visibility into OCI-hosted OracleDB deployments by collecting database metrics, session activity, and operational telemetry through the KloudMate Agent powered by OpenTelemetry. + +This guide walks you through configuring OracleDB SQL query and session receivers so your database telemetry flows into KloudMate for analysis. + +## What This Instrumentation Provides + +With OracleDB monitoring enabled, KloudMate collects telemetry that provides visibility into: + +- Database session and system statistics +- Tablespace utilization and data file metrics +- Resource limits and consumption patterns +- Performance bottlenecks and resource contention +- Server logs and operational events + +This visibility helps identify capacity issues, performance degradation, storage constraints, and availability problems. + +## Prerequisites + +- Oracle Database must be installed and running on OCI +- KloudMate Agent installed on the OracleDB host + +See agent installation for [Linux](../../kloudmate-agent/installation/linux-agent/) and [Windows](../../kloudmate-agent/installation/windows-agent/). + +## Receiver Configuration + +Two named receiver instances are used to logically separate SQL performance queries from session queries. + +## Metric Naming Convention + +The full `sqlquery` receiver configuration used in the OpenTelemetry Collector: + +```yaml +sqlquery/high_cpu: + driver: oracle + host: + database: + port: 1521 + collection_interval: 10s + username: sys + password: password + storage: file_storage + queries: + - sql: > + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + cpu_time/1000000 AS "cpu_seconds", + elapsed_time/1000000 AS "elapsed_seconds",dataase + buffer_gets AS "buffer_gets", + disk_reads AS "disk_reads", + ROUND(cpu_time/DECODE(executions,0,1,executions)/1000000,2) AS "cpu_per_exec" + FROM v$sql + ORDER BY cpu_time DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.sql.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_text + - parsing_schema_name + - sql_id + - metric_name: oracle.sql.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.buffergets + value_column: buffer_gets + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.diskreads + value_column: disk_reads + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.cpuexec + value_column: cpu_per_exec + value_type: double + data_type: gauge + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - sql: > + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + elapsed_time/1000000 AS "elapsed_seconds", + cpu_time/1000000 AS "cpu_seconds", + buffer_gets AS "buffer_gets", + disk_reads AS "disk_reads", + ROUND(elapsed_time/DECODE(executions,0,1,executions)/1000000,2) AS "elapsed_per_exec" + FROM v$sql + ORDER BY elapsed_time DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.el.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.buffergets + value_column: buffer_gets + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.diskreads + value_column: disk_reads + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.elapseexec + value_column: elapsed_per_exec + value_type: double + data_type: gauge + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - sql: | + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + cpu_time/1000000 AS "cpu_seconds", + elapsed_time/1000000 AS "elapsed_seconds" + FROM v$sql + WHERE executions > 0 + ORDER BY executions DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.ex.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.ex.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.ex.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - sql: > + SELECT + originating_timestamp AS "originating_timestamp", + to_char(originating_timestamp, 'DD-MON-YYYY HH24:MI:SS') AS "time", + message_text AS "message_text" + FROM v$diag_alert_ext WHERE message_text LIKE '%deadlock%' ORDER BY + originating_timestamp DESC + tracking_column: originating_timestamp + tracking_start_value: 2024-01-01T00:00:00Z + logs: + - body_column: message_text + attribute_columns: + - time + - originating_timestamp +sqlquery/sessions: + driver: oracle + host: + database: + port: 1521 + collection_interval: 30s + username: sys + password: password + storage: file_storage + queries: + - sql: | + SELECT + s.sid AS "sid", + s.username AS "username", + s.status AS "status", + s.osuser AS "osuser", + s.machine AS "machine", + s.program AS "program", + s.sql_id AS "sql_id", + s.event AS "event", + s.wait_class AS "wait_class", + s.seconds_in_wait AS "seconds_in_wait", + s.state AS "state" + FROM v$session s + WHERE s.status = 'ACTIVE' + AND s.username IS NOT NULL + ORDER BY s.seconds_in_wait DESC + metrics: + - metric_name: oracle.sess.secinwait + value_column: seconds_in_wait + value_type: int + data_type: gauge + attribute_columns: + - sid + - username + - machine + - program + - sql_id + - event + - wait_class + - state + - status +``` From 6e8f69a5d91b7b2f33a997643df346ed05806655 Mon Sep 17 00:00:00 2001 From: vasavi-r Date: Tue, 19 May 2026 12:54:17 +0530 Subject: [PATCH 2/3] Removed seperate oci section and updated oracledb monitoring doc under db integration with receiver conf --- .../oracledb-monitoring.mdx | 269 ++++++++++++++++ src/content/docs/docs/issues.mdx | 2 +- .../oci-observability-integration/_meta.json | 5 - .../oci-observability-integration/index.mdx | 26 -- ...cledb-query-monitoring-instrumentation.mdx | 299 ------------------ 5 files changed, 270 insertions(+), 331 deletions(-) delete mode 100644 src/content/docs/docs/oci-observability-integration/_meta.json delete mode 100644 src/content/docs/docs/oci-observability-integration/index.mdx delete mode 100644 src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx diff --git a/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx b/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx index 9de824bd..9259aecc 100644 --- a/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx +++ b/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx @@ -38,6 +38,275 @@ GRANT SELECT ON DBA_DATA_FILES TO ; GRANT SELECT ON DBA_TABLESPACE_USAGE_METRICS TO ; ``` +## Receiver Configuration + +Two named receiver instances are used to logically separate SQL performance queries from session queries. + +## Metric Naming Convention + +The full `sqlquery` receiver configuration used in the OpenTelemetry Collector: + +```yaml +sqlquery/high_cpu: + driver: oracle + host: + database: + port: 1521 + collection_interval: 10s + username: sys + password: password + storage: file_storage + queries: + - sql: > + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + cpu_time/1000000 AS "cpu_seconds", + elapsed_time/1000000 AS "elapsed_seconds",dataase + buffer_gets AS "buffer_gets", + disk_reads AS "disk_reads", + ROUND(cpu_time/DECODE(executions,0,1,executions)/1000000,2) AS "cpu_per_exec" + FROM v$sql + ORDER BY cpu_time DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.sql.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_text + - parsing_schema_name + - sql_id + - metric_name: oracle.sql.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.buffergets + value_column: buffer_gets + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.diskreads + value_column: disk_reads + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.cpuexec + value_column: cpu_per_exec + value_type: double + data_type: gauge + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - sql: > + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + elapsed_time/1000000 AS "elapsed_seconds", + cpu_time/1000000 AS "cpu_seconds", + buffer_gets AS "buffer_gets", + disk_reads AS "disk_reads", + ROUND(elapsed_time/DECODE(executions,0,1,executions)/1000000,2) AS "elapsed_per_exec" + FROM v$sql + ORDER BY elapsed_time DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.el.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.buffergets + value_column: buffer_gets + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.diskreads + value_column: disk_reads + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.elapseexec + value_column: elapsed_per_exec + value_type: double + data_type: gauge + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - sql: | + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + cpu_time/1000000 AS "cpu_seconds", + elapsed_time/1000000 AS "elapsed_seconds" + FROM v$sql + WHERE executions > 0 + ORDER BY executions DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.ex.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.ex.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.ex.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - sql: > + SELECT + originating_timestamp AS "originating_timestamp", + to_char(originating_timestamp, 'DD-MON-YYYY HH24:MI:SS') AS "time", + message_text AS "message_text" + FROM v$diag_alert_ext WHERE message_text LIKE '%deadlock%' ORDER BY + originating_timestamp DESC + tracking_column: originating_timestamp + tracking_start_value: 2024-01-01T00:00:00Z + logs: + - body_column: message_text + attribute_columns: + - time + - originating_timestamp +sqlquery/sessions: + driver: oracle + host: + database: + port: 1521 + collection_interval: 30s + username: sys + password: password + storage: file_storage + queries: + - sql: | + SELECT + s.sid AS "sid", + s.username AS "username", + s.status AS "status", + s.osuser AS "osuser", + s.machine AS "machine", + s.program AS "program", + s.sql_id AS "sql_id", + s.event AS "event", + s.wait_class AS "wait_class", + s.seconds_in_wait AS "seconds_in_wait", + s.state AS "state" + FROM v$session s + WHERE s.status = 'ACTIVE' + AND s.username IS NOT NULL + ORDER BY s.seconds_in_wait DESC + metrics: + - metric_name: oracle.sess.secinwait + value_column: seconds_in_wait + value_type: int + data_type: gauge + attribute_columns: + - sid + - username + - machine + - program + - sql_id + - event + - wait_class + - state + - status +``` + ## **Configuration Overview** ### **Step 1: Access Agents and OpenTelemetry Collector Configuration** diff --git a/src/content/docs/docs/issues.mdx b/src/content/docs/docs/issues.mdx index 9a2c4b3c..f16cb36c 100644 --- a/src/content/docs/docs/issues.mdx +++ b/src/content/docs/docs/issues.mdx @@ -77,4 +77,4 @@ Access to issue actions is determined by the user’s assigned role: ## Related Resources -- [Setting up Alarm Notifications](./alarms/notifications/) +- [Setting up Alarm Notifications](../alarms/notifications/) diff --git a/src/content/docs/docs/oci-observability-integration/_meta.json b/src/content/docs/docs/oci-observability-integration/_meta.json deleted file mode 100644 index 3940accb..00000000 --- a/src/content/docs/docs/oci-observability-integration/_meta.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "label": "OCI Observability Integration", - "order": 8, - "collapsed": true -} diff --git a/src/content/docs/docs/oci-observability-integration/index.mdx b/src/content/docs/docs/oci-observability-integration/index.mdx deleted file mode 100644 index 7735ab0b..00000000 --- a/src/content/docs/docs/oci-observability-integration/index.mdx +++ /dev/null @@ -1,26 +0,0 @@ ---- -title: "OCI Observability Integration" -description: "Monitor OCI-hosted Oracle Database workloads with KloudMate using OracleDB telemetry collection for query, session, and resource visibility." -sidebar: - label: "Overview" - order: 1 ---- - -KloudMate's OCI observability integration helps you monitor Oracle Database workloads running on Oracle Cloud Infrastructure with centralized telemetry collection and analysis. By connecting your OCI-hosted OracleDB environment through the KloudMate Agent, you can capture database metrics, sessions, and operational signals in one place. - -## How it Works - -KloudMate uses the KloudMate Agent, powered by OpenTelemetry, to connect to your Oracle Database instance with a dedicated monitoring user. The agent collects OracleDB telemetry from the configured receivers and forwards it securely to KloudMate, where you can explore metrics, investigate query behavior, and build dashboards and alerts. - -## Key Capabilities - -- **OracleDB Telemetry Collection**: Collect database metrics and operational signals from Oracle Database instances hosted on OCI. -- **Query and Session Visibility**: Monitor SQL activity and session-related telemetry through OracleDB receiver configuration. -- **Centralized Analysis**: Send OracleDB data into KloudMate for dashboards, alerting, and troubleshooting workflows. -- **Flexible Agent-Based Setup**: Configure the integration through the KloudMate Agent running alongside your OracleDB environment. - -## Available Guides - -Use the following guide to configure OracleDB monitoring for OCI-hosted deployments: - -- **[OracleDB Query Monitoring Instrumentation](./oracledb-query-monitoring-instrumentation/)**: Configure the KloudMate Agent and OracleDB receivers to collect SQL query, session, and resource telemetry. diff --git a/src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx b/src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx deleted file mode 100644 index 17ec6915..00000000 --- a/src/content/docs/docs/oci-observability-integration/oracledb-query-monitoring-instrumentation.mdx +++ /dev/null @@ -1,299 +0,0 @@ ---- -title: "OracleDB Query Monitoring Instrumentation" -description: "Configure OracleDB SQL query and session receivers in the KloudMate Agent to monitor OCI-hosted Oracle Database workloads." -sidebar: - label: "OracleDB Query Monitoring Instrumentation" - order: 2 ---- - -Oracle Database is foundational for many enterprise applications, and robust monitoring is essential for maintaining performance and reliability. KloudMate provides visibility into OCI-hosted OracleDB deployments by collecting database metrics, session activity, and operational telemetry through the KloudMate Agent powered by OpenTelemetry. - -This guide walks you through configuring OracleDB SQL query and session receivers so your database telemetry flows into KloudMate for analysis. - -## What This Instrumentation Provides - -With OracleDB monitoring enabled, KloudMate collects telemetry that provides visibility into: - -- Database session and system statistics -- Tablespace utilization and data file metrics -- Resource limits and consumption patterns -- Performance bottlenecks and resource contention -- Server logs and operational events - -This visibility helps identify capacity issues, performance degradation, storage constraints, and availability problems. - -## Prerequisites - -- Oracle Database must be installed and running on OCI -- KloudMate Agent installed on the OracleDB host - -See agent installation for [Linux](../../kloudmate-agent/installation/linux-agent/) and [Windows](../../kloudmate-agent/installation/windows-agent/). - -## Receiver Configuration - -Two named receiver instances are used to logically separate SQL performance queries from session queries. - -## Metric Naming Convention - -The full `sqlquery` receiver configuration used in the OpenTelemetry Collector: - -```yaml -sqlquery/high_cpu: - driver: oracle - host: - database: - port: 1521 - collection_interval: 10s - username: sys - password: password - storage: file_storage - queries: - - sql: > - SELECT * FROM ( - SELECT - sql_id AS "sql_id", - sql_text AS "sql_text", - parsing_schema_name AS "parsing_schema_name", - executions AS "executions", - cpu_time/1000000 AS "cpu_seconds", - elapsed_time/1000000 AS "elapsed_seconds",dataase - buffer_gets AS "buffer_gets", - disk_reads AS "disk_reads", - ROUND(cpu_time/DECODE(executions,0,1,executions)/1000000,2) AS "cpu_per_exec" - FROM v$sql - ORDER BY cpu_time DESC - ) WHERE ROWNUM <= 10 - metrics: - - metric_name: oracle.sql.cpuseconds - value_column: cpu_seconds - value_type: double - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_text - - parsing_schema_name - - sql_id - - metric_name: oracle.sql.elapseseconds - value_column: elapsed_seconds - value_type: double - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - parsing_schema_name - - sql_text - - metric_name: oracle.sql.executions - value_column: executions - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - parsing_schema_name - - sql_text - - metric_name: oracle.sql.buffergets - value_column: buffer_gets - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - parsing_schema_name - - sql_text - - metric_name: oracle.sql.diskreads - value_column: disk_reads - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - parsing_schema_name - - sql_text - - metric_name: oracle.sql.cpuexec - value_column: cpu_per_exec - value_type: double - data_type: gauge - attribute_columns: - - sql_id - - parsing_schema_name - - sql_text - - sql: > - SELECT * FROM ( - SELECT - sql_id AS "sql_id", - sql_text AS "sql_text", - parsing_schema_name AS "parsing_schema_name", - executions AS "executions", - elapsed_time/1000000 AS "elapsed_seconds", - cpu_time/1000000 AS "cpu_seconds", - buffer_gets AS "buffer_gets", - disk_reads AS "disk_reads", - ROUND(elapsed_time/DECODE(executions,0,1,executions)/1000000,2) AS "elapsed_per_exec" - FROM v$sql - ORDER BY elapsed_time DESC - ) WHERE ROWNUM <= 10 - metrics: - - metric_name: oracle.el.elapseseconds - value_column: elapsed_seconds - value_type: double - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.el.cpuseconds - value_column: cpu_seconds - value_type: double - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.el.executions - value_column: executions - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.el.buffergets - value_column: buffer_gets - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.el.diskreads - value_column: disk_reads - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.el.elapseexec - value_column: elapsed_per_exec - value_type: double - data_type: gauge - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - sql: | - SELECT * FROM ( - SELECT - sql_id AS "sql_id", - sql_text AS "sql_text", - parsing_schema_name AS "parsing_schema_name", - executions AS "executions", - cpu_time/1000000 AS "cpu_seconds", - elapsed_time/1000000 AS "elapsed_seconds" - FROM v$sql - WHERE executions > 0 - ORDER BY executions DESC - ) WHERE ROWNUM <= 10 - metrics: - - metric_name: oracle.ex.executions - value_column: executions - value_type: int - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.ex.cpuseconds - value_column: cpu_seconds - value_type: double - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - metric_name: oracle.ex.elapseseconds - value_column: elapsed_seconds - value_type: double - data_type: sum - aggregation: cumulative - monotonic: true - attribute_columns: - - sql_id - - sql_text - - parsing_schema_name - - sql: > - SELECT - originating_timestamp AS "originating_timestamp", - to_char(originating_timestamp, 'DD-MON-YYYY HH24:MI:SS') AS "time", - message_text AS "message_text" - FROM v$diag_alert_ext WHERE message_text LIKE '%deadlock%' ORDER BY - originating_timestamp DESC - tracking_column: originating_timestamp - tracking_start_value: 2024-01-01T00:00:00Z - logs: - - body_column: message_text - attribute_columns: - - time - - originating_timestamp -sqlquery/sessions: - driver: oracle - host: - database: - port: 1521 - collection_interval: 30s - username: sys - password: password - storage: file_storage - queries: - - sql: | - SELECT - s.sid AS "sid", - s.username AS "username", - s.status AS "status", - s.osuser AS "osuser", - s.machine AS "machine", - s.program AS "program", - s.sql_id AS "sql_id", - s.event AS "event", - s.wait_class AS "wait_class", - s.seconds_in_wait AS "seconds_in_wait", - s.state AS "state" - FROM v$session s - WHERE s.status = 'ACTIVE' - AND s.username IS NOT NULL - ORDER BY s.seconds_in_wait DESC - metrics: - - metric_name: oracle.sess.secinwait - value_column: seconds_in_wait - value_type: int - data_type: gauge - attribute_columns: - - sid - - username - - machine - - program - - sql_id - - event - - wait_class - - state - - status -``` From 4bf8c6cc84c25bb5e0f2db35740209fcea7d08c3 Mon Sep 17 00:00:00 2001 From: vasavi-r Date: Thu, 21 May 2026 08:10:13 +0530 Subject: [PATCH 3/3] `Update OracleDB monitoring documentation and configuration files` --- .../oracledb-monitoring.mdx | 513 +++++++++++++----- 1 file changed, 383 insertions(+), 130 deletions(-) diff --git a/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx b/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx index 9259aecc..0bf72fe5 100644 --- a/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx +++ b/src/content/docs/docs/database-monitoring/database-integrations/oracledb-monitoring.mdx @@ -2,6 +2,7 @@ title: "OracleDB" description: "Documentation for OracleDB Monitoring" --- + Oracle Database (OracleDB) is foundational for many enterprise applications, and robust monitoring is essential for maintaining performance and reliability. KloudMate provides comprehensive visibility into OracleDB by delivering real-time insights through logs and metrics using the KloudMate Agent powered by OpenTelemetry. OracleDB Monitoring in KloudMate enables centralized monitoring of Oracle Database instances running on AWS EC2, Azure Virtual Machines, or on-premise servers. @@ -12,18 +13,18 @@ OracleDB Monitoring in KloudMate enables centralized monitoring of Oracle Databa With OracleDB Monitoring enabled, KloudMate collects telemetry that provides visibility into: -• Database session and system statistics -• Tablespace utilization and data file metrics -• Resource limits and consumption patterns -• Performance bottlenecks and resource contention -• Server logs and operational events +- Database session and system statistics +- Tablespace utilization and data file metrics +- Resource limits and consumption patterns +- Performance bottlenecks and resource contention +- Server logs and operational events This visibility helps identify capacity issues, performance degradation, storage constraints, and availability problems. ### Prerequisites -• Oracle Database must be installed and running -• KloudMate Agent installed on the OracleDB host (see agent installation for [Linux](../../../kloudmate-agent/installation/linux-agent/) and [Windows](../../../kloudmate-agent/installation/windows-agent/)) +- Oracle Database must be installed and running +- KloudMate Agent installed on the OracleDB host (see agent installation for [Linux](../../../kloudmate-agent/installation/linux-agent/) and [Windows](../../../kloudmate-agent/installation/windows-agent/)) ### Required Permissions @@ -42,9 +43,60 @@ GRANT SELECT ON DBA_TABLESPACE_USAGE_METRICS TO ; Two named receiver instances are used to logically separate SQL performance queries from session queries. +| Receiver | Purpose | +| --- | --- | +| `sqlquery/high_cpu` | SQL performance queries for top CPU, top elapsed time, top executions, and deadlock logs | +| `sqlquery/sessions` | Active session and wait event queries | + ## Metric Naming Convention -The full `sqlquery` receiver configuration used in the OpenTelemetry Collector: +| Metric Prefix | Description | +| --- | --- | +| `oracle.sql.*` | Top SQL by CPU time | +| `oracle.el.*` | Top SQL by elapsed time | +| `oracle.ex.*` | Top SQL by executions | +| `oracle.sess.*` | Active session wait events | + +## Configuration Overview + +### **Step 1: Access Agents and OpenTelemetry Collector Configuration** + +- Log in to the KloudMate platform +- Go to **Settings → Agents** +- Select the agent running on the PostgreSQL host +- Click **Actions → Collector Configuration** +- YAML editor opens for configuration + +![image](./images/mongodb-monitoring-1.png) + +### **Step 2: Configure the OracleDB Receiver** + +:::note + *This receiver collects server-level metrics and system resource usage.* +::: + +```yaml +receivers: + oracledb: + datasource: "oracle://otel:passwd@/XEPDB1" +``` + +Connection string format: `oracle://username:password@host:port/service_name` + +Replace: + +- `otel` → monitoring username +- `passwd` → monitoring user password +- `` → OracleDB host IP +- `XEPDB1` → PDB/service name (adjust for your database) + +### **Step 3: Configure the SQL Query Receiver** + +:::note + *Use this receiver to monitor and collect SQL query performance metrics.* +::: + +Two named receiver instances are used to logically separate SQL performance queries from session queries. ```yaml sqlquery/high_cpu: @@ -65,7 +117,7 @@ sqlquery/high_cpu: parsing_schema_name AS "parsing_schema_name", executions AS "executions", cpu_time/1000000 AS "cpu_seconds", - elapsed_time/1000000 AS "elapsed_seconds",dataase + elapsed_time/1000000 AS "elapsed_seconds", buffer_gets AS "buffer_gets", disk_reads AS "disk_reads", ROUND(cpu_time/DECODE(executions,0,1,executions)/1000000,2) AS "cpu_per_exec" @@ -307,35 +359,7 @@ sqlquery/sessions: - status ``` -## **Configuration Overview** - -### **Step 1: Access Agents and OpenTelemetry Collector Configuration** - -- Log in to the KloudMate platform -- Go to **Settings → Agents** -- Select the agent running on the PostgreSQL host -- Click **Actions → Collector Configuration** -- YAML editor opens for configuration - -![image](./images/mongodb-monitoring-1.png) - -### **Step 2: Configure the OracleDB Receiver** - -```yaml -receivers: - oracledb: - datasource: "oracle://otel:passwd@/XEPDB1" -``` - -Connection string format: `oracle://username:password@host:port/service_name` - -Replace: -• `otel` → monitoring username -• `passwd` → monitoring user password -• `` → OracleDB host IP -• `XEPDB1` → PDB/service name (adjust for your database) - -### Step 3: Export Data to KloudMate +### **Step 4: Export Data to KloudMate** ```yaml exporters: @@ -351,48 +375,271 @@ This enables forwarding telemetry to KloudMate for analysis and visualization. ```yaml extensions: - health_check: - pprof: - endpoint: 0.0.0.0:1777 - zpages: - endpoint: 0.0.0.0:55679 + file_storage: + create_directory: true receivers: - otlp: - protocols: - grpc: - endpoint: 0.0.0.0:4317 - http: - endpoint: 0.0.0.0:4318 - - opencensus: - endpoint: 0.0.0.0:55678 - oracledb: datasource: "oracle://otel:passwd@/XEPDB1" - # Collect own metrics - prometheus: - config: - scrape_configs: - - job_name: 'otel-collector' - scrape_interval: 10s - static_configs: - - targets: ['0.0.0.0:8888'] - - jaeger: - protocols: - grpc: - endpoint: 0.0.0.0:14250 - thrift_binary: - endpoint: 0.0.0.0:6832 - thrift_compact: - endpoint: 0.0.0.0:6831 - thrift_http: - endpoint: 0.0.0.0:14268 - - zipkin: - endpoint: 0.0.0.0:9411 + sqlquery/high_cpu: + driver: oracle + host: + database: XEPDB1 + port: 1521 + collection_interval: 10s + username: sys + password: + storage: file_storage + queries: + - sql: > + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + cpu_time/1000000 AS "cpu_seconds", + elapsed_time/1000000 AS "elapsed_seconds", + buffer_gets AS "buffer_gets", + disk_reads AS "disk_reads", + ROUND(cpu_time/DECODE(executions,0,1,executions)/1000000,2) AS "cpu_per_exec" + FROM v$sql + ORDER BY cpu_time DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.sql.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_text + - parsing_schema_name + - sql_id + - metric_name: oracle.sql.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.buffergets + value_column: buffer_gets + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.diskreads + value_column: disk_reads + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - metric_name: oracle.sql.cpuexec + value_column: cpu_per_exec + value_type: double + data_type: gauge + attribute_columns: + - sql_id + - parsing_schema_name + - sql_text + - sql: > + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + elapsed_time/1000000 AS "elapsed_seconds", + cpu_time/1000000 AS "cpu_seconds", + buffer_gets AS "buffer_gets", + disk_reads AS "disk_reads", + ROUND(elapsed_time/DECODE(executions,0,1,executions)/1000000,2) AS "elapsed_per_exec" + FROM v$sql + ORDER BY elapsed_time DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.el.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.buffergets + value_column: buffer_gets + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.diskreads + value_column: disk_reads + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.el.elapseexec + value_column: elapsed_per_exec + value_type: double + data_type: gauge + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - sql: | + SELECT * FROM ( + SELECT + sql_id AS "sql_id", + sql_text AS "sql_text", + parsing_schema_name AS "parsing_schema_name", + executions AS "executions", + cpu_time/1000000 AS "cpu_seconds", + elapsed_time/1000000 AS "elapsed_seconds" + FROM v$sql + WHERE executions > 0 + ORDER BY executions DESC + ) WHERE ROWNUM <= 10 + metrics: + - metric_name: oracle.ex.executions + value_column: executions + value_type: int + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.ex.cpuseconds + value_column: cpu_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - metric_name: oracle.ex.elapseseconds + value_column: elapsed_seconds + value_type: double + data_type: sum + aggregation: cumulative + monotonic: true + attribute_columns: + - sql_id + - sql_text + - parsing_schema_name + - sql: > + SELECT + originating_timestamp AS "originating_timestamp", + to_char(originating_timestamp, 'DD-MON-YYYY HH24:MI:SS') AS "time", + message_text AS "message_text" + FROM v$diag_alert_ext WHERE message_text LIKE '%deadlock%' ORDER BY + originating_timestamp DESC + tracking_column: originating_timestamp + tracking_start_value: 2024-01-01T00:00:00Z + logs: + - body_column: message_text + attribute_columns: + - time + - originating_timestamp + sqlquery/sessions: + driver: oracle + host: + database: XEPDB1 + port: 1521 + collection_interval: 30s + username: sys + password: password + storage: file_storage + queries: + - sql: | + SELECT + s.sid AS "sid", + s.username AS "username", + s.status AS "status", + s.osuser AS "osuser", + s.machine AS "machine", + s.program AS "program", + s.sql_id AS "sql_id", + s.event AS "event", + s.wait_class AS "wait_class", + s.seconds_in_wait AS "seconds_in_wait", + s.state AS "state" + FROM v$session s + WHERE s.status = 'ACTIVE' + AND s.username IS NOT NULL + ORDER BY s.seconds_in_wait DESC + metrics: + - metric_name: oracle.sess.secinwait + value_column: seconds_in_wait + value_type: int + data_type: gauge + attribute_columns: + - sid + - username + - machine + - program + - sql_id + - event + - wait_class + - state + - status processors: memory_limiter: @@ -402,6 +649,22 @@ processors: batch: send_batch_size: 1000 timeout: 10s + resource: + attributes: + - key: service.name + action: insert + from_attribute: host.name + resourcedetection: + detectors: + - system + system: + resource_attributes: + host.name: + enabled: true + host.id: + enabled: true + os.type: + enabled: false exporters: debug: @@ -412,28 +675,20 @@ exporters: Authorization: service: - pipelines: - - traces: - receivers: [otlp, opencensus, jaeger, zipkin] - processors: [batch] - exporters: [debug, otlphttp] - metrics: - receivers: [oracledb] - processors: [memory_limiter, batch] + receivers: [oracledb, sqlquery/high_cpu, sqlquery/sessions] + processors: [resourcedetection, resource, memory_limiter, batch] exporters: [debug, otlphttp] - logs: - receivers: [otlp, oracledb] - processors: [memory_limiter, batch] + receivers: [oracledb, sqlquery/high_cpu] + processors: [resourcedetection, resource, memory_limiter, batch] exporters: [debug, otlphttp] - - extensions: [health_check, pprof, zpages] + extensions: + - file_storage ``` -## Post‑Integration Data Validation +## Post-Integration Data Validation Verify that metrics are flowing into KloudMate using the **Explore** view. @@ -444,51 +699,49 @@ After the agent restarts: 3. Select **OpenTelemetry → Metrics** 4. Choose a OracleDB metric and run the query -Seeing time-series data confirms that OracleDB telemetry is flowing successfully. +Seeing time-series data confirms that OracleDB telemetry is flowing successfully. -### Set Up KloudMate Dashboards and Alerts +## Set Up KloudMate Dashboards and Alerts Access KloudMate and create dashboards to visualize OracleDB metrics and logs. Configure alerting rules for critical thresholds and unusual activity. ![image](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcp9ByEpItmbQQ-2PLWRiN9UoHEzg95EcQqUf_D5XC4Nc3u_mMrSsD0Xh3dS7f1CxBEkiiA4SZR51fXLGuCpc3H3DBqYTYyaYtGdynxVFwU9XUknqF9ODpqROBuaiKpfuBEQ4EHAna66CAQ0oDygqr37LHk?key=yOqtikL5-HBgd08NCIVsvg) -## **Default Metrics:** - -| **Default Metrics** | -| ----------------------------------- | -| oracledb\_cpu\_time | -| oracledb\_dml\_locks\_limit | -| oraclb\_dml\_locks\_usage | -| oracledb\_enqueue\_deadlocks | -| oracledb\_enqueue\_locks\_limit | -| oracledb\_enqueue\_locks\_usage | -| oracledb\_enqueue\_resources\_limit | -| oracledb\_enqueue\_resources\_usage | -| oracledb\_exchange\_deadlocks | -| oracledb\_executions | -| oracledb\_hard\_parses | -| Oracledb\_logical\_reads | -| oracledb\_parse\_calls | -| oracledb\_pga\_memory | -| oracledb\_physical\_reads | -| oracledb\_processes\_limit | -| oracledb\_processes\_usage | -| oracledb\_sessions\_limit | -| oracledb\_sessions\_usage | -| oracledb\_tablespace\_size\_limit | -| Oracledb\_tablespace\_size\_usage | -| oracledb\_transactions\_limit | -| oracledb\_transactions\_usage | -| oracledb\_user\_commits | -| oracledb\_user\_rollbacks | - -| **Optional Metrics** | -| -------------------------- | -| oracledb\_consistent\_gets | -| oracledb\_db\_block\_gets | +## Default Metrics + +The following metrics are collected through the `oracledb` receiver: + +| **Default Metrics** | +| --- | +| oracledb_cpu_time | +| oracledb_dml_locks_limit | +| oraclb_dml_locks_usage | +| oracledb_enqueue_deadlocks | +| oracledb_enqueue_locks_limit | +| oracledb_enqueue_locks_usage | +| oracledb_enqueue_resources_limit | +| oracledb_enqueue_resources_usage | +| oracledb_exchange_deadlocks | +| oracledb_executions | +| oracledb_hard_parses | +| Oracledb_logical_reads | +| oracledb_parse_calls | +| oracledb_pga_memory | +| oracledb_physical_reads | +| oracledb_processes_limit | +| oracledb_processes_usage | +| oracledb_sessions_limit | +| oracledb_sessions_usage | +| oracledb_tablespace_size_limit | +| Oracledb_tablespace_size_usage | +| oracledb_transactions_limit | +| oracledb_transactions_usage | +| oracledb_user_commits | +| oracledb_user_rollbacks | + +| **Optional Metrics** | +| --- | +| oracledb_consistent_gets | +| oracledb_db_block_gets | For the complete metrics list, refer to the [metrics reference](https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/main/receiver/oracledbreceiver/documentation.md). - -**** - -