Monitoring d'Oracle Database avec NRDOT

Aperçu

Nous travaillons toujours sur cette fonctionnalité, mais nous aimerions que vous l'essayiez !

Cette fonctionnalité est actuellement fournie dans le cadre d'un aperçu conformément à nos politiques de pré-sortie.

New Relic permet désormais à votre équipe de monitorer les performances de votre base de données Oracle à l'aide de la distribution New Relic d'OpenTelemetry (NRDOT) et des fonctionnalités de monitoring de bases de données de New Relic. Cette intégration offre une visibilité complète sur les métriques de base de données, les performances des requêtes et la santé du système à l'aide du collecteur NRDOT.

Cette approche basée sur NRDOT complète notre On-Host Integration (OHI) existante en s'appuyant sur les standards OpenTelemetry pour le monitoring des bases de données, facilitant ainsi l'intégration avec votre pile d'observabilité existante.

Prérequis

Avant de commencer, assurez-vous d’avoir les éléments suivants :

Clé de licenceNew Relic valide
Architecture prise en charge : Linux avec AMD64 et ARM64
Connectivité réseau vers le point de terminaison OTLP de New Relic
Oracle Database 19c ou version ultérieure
Pour la base de données Oracle, vous disposez d'Oracle Instant Client sur la machine exécutant le collecteur NRDOT

Configurer le NRDOT Collector pour le monitoring d'Oracle Database

Vous pouvez configurer le monitoring d'Oracle Database à l'aide du collecteur NRDOT dans des environnements sur l'hôte (multitenant) ou RDS. Sélectionnez la configuration appropriée en fonction de votre environnement de base de données et suivez les étapes.

Conseil

Le NRDOT Collector collecte les données de télémétrie liées à la fois à l'infrastructure et à la base de données, afin que vous puissiez disposer d'une solution d'observabilité unifiée pour votre environnement Oracle Database dans New Relic.

Vous pouvez configurer le monitoring d'Oracle Database à l'aide du NRDOT Collector dans des environnements sur l'hôte ou multitenant. Pour installer le NRDOT Collector dans des environnements sur l'hôte (multi-locataires), suivez ces étapes :

Méthode d'installation

Sélectionnez la méthode de distribution de l'installation appropriée pour votre environnement Linux :

Important

Il est recommandé d'installer le collecteur NRDOT sur le même hôte que votre instance Oracle Database pour visualiser les métriques au niveau de l'infrastructure pour le monitoring des performances des requêtes.

Pour les systèmes Debian/Ubuntu, exécutez :
bash
```
$curl -L -o nrdot-collector-host-linux-amd64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-amd64-latest.deb
$sudo dpkg -i nrdot-collector-host-linux-amd64-latest
```

Pour les systèmes RHEL/CentOS/OEL, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-amd64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-amd64-latest.rpm
$sudo rpm -ivh nrdot-collector-host-linux-amd64-latest

Pour les systèmes Debian/Ubuntu, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-arm64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-arm64-latest.deb
$sudo dpkg -i nrdot-collector-host-linux-arm64-latest

Pour les systèmes RHEL/CentOS/OEL, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-arm64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-arm64-latest.rpm
$sudo rpm -ivh nrdot-collector-host-linux-arm64-latest

Configurer l'utilisateur de la base de données

Créez un utilisateur de monitoring avec les privilèges nécessaires pour votre base de données Oracle multitenant. Cela nécessite de créer un utilisateur commun avec le préfixe C##.

Connectez-vous à la base de données racine en tant qu'administrateur :
```
CREATE USER c##<YOUR_DB_USERNAME> IDENTIFIED BY "<USER_PASSWORD>";
```
Conseil
Assurez-vous que votre USER_PASSWORD respecte les exigences d'Oracle en matière de mot de passe du nouvel utilisateur.

Accorder des privilèges de monitoring pour une base de données multitenant

Exécutez les instructions SQL suivantes pour accorder des privilèges de monitoring. Utilisez le format de nom d'utilisateur correct avec le préfixe C## pour la base de données multi-locataire :

ALTER USER c##<YOUR_DB_USERNAME> SET CONTAINER_DATA=ALL CONTAINER=CURRENT;
GRANT CREATE SESSION TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SET CONTAINER TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT CONNECT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SESSION TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SYSSTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SESSTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$STATNAME TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SYSTEM_EVENT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SHARED_SERVER TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$DISPATCHER TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$CIRCUIT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$RESOURCE_LIMIT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$LOCK TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$DATABASE TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$PARAMETER TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SQLAREA TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SQL TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$SQL_PLAN TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.V_$PDBS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$INSTANCE TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SGA TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SESSTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$STATNAME TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SYSSTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SQLAREA TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$LIBRARYCACHE TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$ROWCACHE TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$PGASTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$CONTAINERS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$PDBS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$CON_SYSMETRIC TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SYSMETRIC TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$FILESTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SYSTEM_EVENT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$ACTIVE_SERVICES TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SESSION TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$SESSION_WAIT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON SYS.GV_$ROLLSTAT TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON DBA_OBJECTS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON DBA_TABLESPACES TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON DBA_TABLESPACE_USAGE_METRICS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON DBA_DATA_FILES TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON DBA_USERS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON CDB_SERVICES TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON CDB_DATA_FILES TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON CDB_TABLESPACE_USAGE_METRICS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON CDB_USERS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON CDB_PDBS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON ALL_USERS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON ALL_VIEWS TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;
GRANT SELECT ON GLOBAL_NAME TO c##<YOUR_DB_USERNAME> CONTAINER=ALL;

Configurer le collecteur NRDOT

Modifiez votre fichier config.yaml disponible à /etc/nrdot-collector-host/, puis ajoutez l'extrait de code suivant :

Important

Si vous êtes déjà utilisateur de NRDOT Collector, assurez-vous de fusionner la configuration ci-dessus avec votre fichier config.yaml existant. Cela inclut l'ajout des nouveaux récepteurs, processeurs et exportateurs pour le monitoring d'Oracle Database, tout en conservant vos configurations actuelles.

extensions:
  health_check:
receivers:
  otlp:
    protocols:
      grpc:
      http:
  hostmetrics:
    collection_interval: 60s
    scrapers:
      cpu:
        metrics:
          system.cpu.time:
            enabled: false
          system.cpu.utilization:
            enabled: true
      load:
      memory:
        metrics:
          system.memory.utilization:
            enabled: true
      paging:
        metrics:
          system.paging.utilization:
            enabled: false
          system.paging.faults:
            enabled: false
      filesystem:
        metrics:
          system.filesystem.utilization:
            enabled: true
      disk:
        metrics:
          system.disk.merged:
            enabled: false
          system.disk.pending_operations:
            enabled: false
          system.disk.weighted_io_time:
            enabled: false
      network:
        metrics:
          system.network.connections:
            enabled: false
      # Uncomment to enable process metrics, which can be noisy but valuable.
      # processes:
      # process:
      #   metrics:
      #     process.cpu.utilization:
      #       enabled: true
      #     process.cpu.time:
      #       enabled: false
  filelog:
    include:
      - /var/log/alternatives.log
      - /var/log/cloud-init.log
      - /var/log/auth.log
      - /var/log/dpkg.log
      - /var/log/syslog
      - /var/log/messages
      - /var/log/secure
      - /var/log/yum.log
  newrelicoracledb/cdb:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<YOUR_CDB_SERVICE_NAME>"
    collection_interval: 30s
    timeout: 30s
    # enable_tablespace_scraper: true
    # enable_core_scraper: true
    # enable_system_scraper: true
    # enable_connection_scraper: true
    # enable_container_scraper: true
    # enable_database_info_scraper: true
  newrelicoracledb/pdb:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<YOUR_CDB_SERVICE_NAME>"
    collection_interval: 30s
    timeout: 30s
    pdb_services: ["ALL"]
    # query_monitoring_response_time_threshold: 500
    # query_monitoring_count_threshold: 30
    # enable_query_monitoring: true
    # enable_pdb_scraper: true

processors:
  metricstransform:
    transforms:
      - include: system.cpu.utilization
        action: update
        operations:
          - action: aggregate_labels
            label_set: [ state ]
            aggregation_type: mean
      - include: system.paging.operations
        action: update
        operations:
          - action: aggregate_labels
            label_set: [ direction ]
            aggregation_type: sum
  filter/exclude_cpu_utilization:
    metrics:
      datapoint:
        - 'metric.name == "system.cpu.utilization" and attributes["state"] == "interrupt"'
        - 'metric.name == "system.cpu.utilization" and attributes["state"] == "nice"'
        - 'metric.name == "system.cpu.utilization" and attributes["state"] == "softirq"'
  filter/exclude_memory_utilization:
    metrics:
      datapoint:
        - 'metric.name == "system.memory.utilization" and attributes["state"] == "slab_unreclaimable"'
        - 'metric.name == "system.memory.utilization" and attributes["state"] == "inactive"'
        - 'metric.name == "system.memory.utilization" and attributes["state"] == "cached"'
        - 'metric.name == "system.memory.utilization" and attributes["state"] == "buffered"'
        - 'metric.name == "system.memory.utilization" and attributes["state"] == "slab_reclaimable"'
  filter/exclude_memory_usage:
    metrics:
      datapoint:
        - 'metric.name == "system.memory.usage" and attributes["state"] == "slab_unreclaimable"'
        - 'metric.name == "system.memory.usage" and attributes["state"] == "inactive"'
  filter/exclude_filesystem_utilization:
    metrics:
      datapoint:
        - 'metric.name == "system.filesystem.utilization" and attributes["type"] == "squashfs"'
  filter/exclude_filesystem_usage:
    metrics:
      datapoint:
        - 'metric.name == "system.filesystem.usage" and attributes["type"] == "squashfs"'
        - 'metric.name == "system.filesystem.usage" and attributes["state"] == "reserved"'
  filter/exclude_filesystem_inodes_usage:
    metrics:
      datapoint:
        - 'metric.name == "system.filesystem.inodes.usage" and attributes["type"] == "squashfs"'
        - 'metric.name == "system.filesystem.inodes.usage" and attributes["state"] == "reserved"'
  filter/exclude_system_disk:
    metrics:
      datapoint:
        - 'metric.name == "system.disk.operations" and IsMatch(attributes["device"], "^loop.*") == true'
        - 'metric.name == "system.disk.merged" and IsMatch(attributes["device"], "^loop.*") == true'
        - 'metric.name == "system.disk.io" and IsMatch(attributes["device"], "^loop.*") == true'
        - 'metric.name == "system.disk.io_time" and IsMatch(attributes["device"], "^loop.*") == true'
        - 'metric.name == "system.disk.operation_time" and IsMatch(attributes["device"], "^loop.*") == true'
  filter/exclude_system_paging:
    metrics:
      datapoint:
        - 'metric.name == "system.paging.usage" and attributes["state"] == "cached"'
        - 'metric.name == "system.paging.operations" and attributes["type"] == "cached"'
  filter/exclude_network:
    metrics:
      datapoint:
        - 'IsMatch(metric.name, "^system.network.*") == true and attributes["device"] == "lo"'
  attributes/exclude_system_paging:
    include:
      match_type: strict
      metric_names:
        - system.paging.operations
    actions:
      - key: type
        action: delete
  transform/clear_metadata:
    metric_statements:
      - context: metric
        statements:
          - set(metric.description, "")
          - set(metric.unit, "")
  filter/exec_plan_and_query_details_include:
    metrics:
      include:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details
  filter/exec_plan_and_query_details_exclude:
    metrics:
      exclude:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details
  cumulativetodelta/oracle:
    include:
      match_type: strict
      metrics:
        - newrelicoracledb.connection.bytes_received
        - newrelicoracledb.connection.bytes_sent
        - newrelicoracledb.connection.execute_count
        - newrelicoracledb.connection.logons_cumulative
        - newrelicoracledb.connection.parse_count_hard
        - newrelicoracledb.connection.parse_count_total
        - newrelicoracledb.connection.sqlnet_roundtrips
        - newrelicoracledb.connection.user_commits
        - newrelicoracledb.connection.user_rollbacks
  transform/host:
    metric_statements:
      - context: metric
        statements:
          - set(metric.description, "")
          - set(metric.unit, "")
  transform:
    trace_statements:
      - context: span
        statements:
          - truncate_all(span.attributes, 4095)
          - truncate_all(resource.attributes, 4095)
    log_statements:
      - context: log
        statements:
          - truncate_all(log.attributes, 4095)
          - truncate_all(resource.attributes, 4095)
  memory_limiter:
    check_interval: 1s
    limit_mib: ${env:NEW_RELIC_MEMORY_LIMIT_MIB:-100}
  batch:
  resourcedetection:
    detectors: ["system"]
    system:
      hostname_sources: ["os"]
      resource_attributes:
        host.id:
          enabled: true
  resourcedetection/db_safe:
    detectors: ["system"]
    override: false
    system:
      hostname_sources: ["os"]
      resource_attributes:
        host.id:
          enabled: true
  resourcedetection/cloud:
    detectors: ["gcp", "ec2", "azure"]
    timeout: 2s
    override: true
  resourcedetection/env:
    detectors: ["env"]
    timeout: 2s
    override: true

connectors:
  metricsaslogs:
    include_resource_attributes: true
    include_scope_info: true

exporters:
  otlp:
    endpoint: "<YOUR_NEWRELIC_OTLP_ENDPOINT>"
    headers:
      api-key: "<YOUR_NEWRELIC_API_KEY>"
    compression: gzip

service:
  pipelines:
    metrics/host:
      receivers: [hostmetrics]
      processors:
        - memory_limiter
        - metricstransform
        - filter/exclude_cpu_utilization
        - filter/exclude_memory_utilization
        - filter/exclude_memory_usage
        - filter/exclude_filesystem_utilization
        - filter/exclude_filesystem_usage
        - filter/exclude_filesystem_inodes_usage
        - filter/exclude_system_disk
        - filter/exclude_network
        - attributes/exclude_system_paging
        - transform/host
        - resourcedetection
        - resourcedetection/cloud
        - resourcedetection/env
        - cumulativetodelta/oracle
        - batch
      exporters: [otlp]
    traces:
      receivers: [otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, batch]
      exporters: [otlp]
    metrics:
      receivers: [otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, batch]
      exporters: [otlp]
    logs:
      receivers: [otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, batch]
      exporters: [otlp]
    metrics/oracledb:
      receivers: [newrelicoracledb/cdb, newrelicoracledb/pdb]
      processors: [memory_limiter, resourcedetection/db_safe, batch, transform/clear_metadata, filter/exec_plan_and_query_details_exclude]
      exporters: [otlp]
    metrics/exec_plan_and_query_details_to_logs:
      receivers: [newrelicoracledb/cdb, newrelicoracledb/pdb]
      processors: [filter/exec_plan_and_query_details_include]
      exporters: [metricsaslogs]
    logs/oracledb:
      receivers: [metricsaslogs]
      processors: [memory_limiter, resourcedetection/db_safe, batch]
      exporters: [otlp]
  extensions: [health_check]

Définissez les paramètres requis suivants dans le fichier de configuration :

paramètres	Description
`<YOUR_DB_HOST>`	Saisissez le nom d'hôte de votre base de données Oracle.
`<YOUR_DB_PORT>`	Saisissez le port de votre base de données Oracle.
`<USERNAME>`	Saisissez le nom d'utilisateur de votre base de données.
`<PASSWORD>`	Saisissez le mot de passe de votre base de données.
`<YOUR_CDB_SERVICE_NAME>`	Saisissez le nom de votre service Oracle.
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Saisissez le point de terminaison OTLP New Relic. Pour plus d'informations, consultez la documentation sur les endpoints OTLP New Relic.
`<YOUR_NEWRELIC_API_KEY>`	Saisissez votre clé API New Relic.
`pdb_services`	Sélectionnez les services PDB à monitorer parmi les options suivantes : Vide ou nil : collecter uniquement les données de service spécifiées `["ALL"]`: Collecter tous les services PDB (à l'exclusion de la CDB) `["pdb1", "pdb2"]`: Collecter uniquement les services PDB spécifiés
`enable_query_monitoring`	Obtenez des métriques de monitoring des requêtes telles que les sessions lentes, actives, en attente et bloquantes, ainsi que le plan d'exécution. La valeur par défaut est définie sur `false`
`query_monitoring_response_time_threshold`	Définissez le seuil de temps de réponse des requêtes (en ms). Capture les requêtes qui dépassent ce seuil. La valeur par défaut est définie sur 500 ms.
`query_monitoring_count_threshold`	Le nombre d'enregistrements pour chaque métrique de performance des requêtes. La valeur par défaut est définie sur 30

Conseil

Pour plus de détails sur la configuration du point de terminaison OTLP New Relic et les bonnes pratiques OpenTelemetry, consultez la documentation OpenTelemetry OTLP.

Redémarrer le collecteur NRDOT

Après avoir mis à jour votre configuration, redémarrez le collecteur NRDOT :

bash

$sudo systemctl restart nrdot-collector-host
$sudo systemctl status nrdot-collector-host

Conseil

Redémarrez toujours le collecteur NRDOT après avoir modifié la configuration pour garantir la prise en compte des nouveaux paramètres.

(Facultatif) Configuration multi-récepteur

Le binaire nrdot-collector-host prend en charge une configuration multi-récepteur au sein d'un seul config.yaml pour monitorer plusieurs instances de base de données Oracle à l'aide d'identifiants uniques. L'exemple config.yaml ci-dessous montre comment configurer plusieurs récepteurs pour différentes instances sur l'hôte (multi-locataires) tout en partageant des processeurs et des exportateurs communs.

receivers:
  newrelicoracledb/cdb1:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<YOUR_CDB1_SERVICE_NAME>"
    collection_interval: 30s
    timeout: 30s
    # enable_tablespace_scraper: true
    # enable_core_scraper: true
    # enable_system_scraper: true
    # enable_connection_scraper: true
    # enable_container_scraper: true
    # enable_database_info_scraper: true

  # First CDB's PDB configuration
  newrelicoracledb/pdb1:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<YOUR_CDB2_SERVICE_NAME>"
    collection_interval: 30s
    timeout: 30s
    pdb_services: ["ALL"]
    # query_monitoring_response_time_threshold: 500
    # query_monitoring_count_threshold: 30
    # enable_query_monitoring: true
    # enable_pdb_scraper: true

  # Second CDB configuration
  newrelicoracledb/cdb2:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<YOUR_CDB2_SERVICE_NAME>"
    collection_interval: 30s
    timeout: 30s
    # enable_tablespace_scraper: true
    # enable_core_scraper: true
    # enable_system_scraper: true
    # enable_connection_scraper: true
    # enable_container_scraper: true
    # enable_database_info_scraper: true

  # Second CDB's PDB configuration
  newrelicoracledb/pdb2:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<YOUR_CDB2_SERVICE_NAME>"
    collection_interval: 30s
    timeout: 30s
    pdb_services: ["ALL"]
    # query_monitoring_response_time_threshold: 500
    # query_monitoring_count_threshold: 30
    # enable_query_monitoring: true
    # enable_pdb_scraper: true

processors:
  memory_limiter/oracle:
    check_interval: 1s
    limit_mib: ${env:NEW_RELIC_MEMORY_LIMIT_MIB:-100}

  cumulativetodelta/oracle:
    include:
      match_type: strict
      metrics:
        - newrelicoracledb.connection.bytes_received
        - newrelicoracledb.connection.bytes_sent
        - newrelicoracledb.connection.execute_count
        - newrelicoracledb.connection.logons_cumulative
        - newrelicoracledb.connection.parse_count_hard
        - newrelicoracledb.connection.parse_count_total
        - newrelicoracledb.connection.sqlnet_roundtrips
        - newrelicoracledb.connection.user_commits
        - newrelicoracledb.connection.user_rollbacks

  transform/oracle_clear_metadata:
    metric_statements:
      - context: metric
        statements:
          - set(metric.description, "")
          - set(metric.unit, "")
    log_statements:
      - context: log
        statements:
          - set(body, "")

  filter/exec_plan_and_query_details_include:
    metrics:
      include:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details

  filter/exec_plan_and_query_details_exclude:
    metrics:
      exclude:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details

  resourcedetection/oracle_db_safe:
    detectors: ["system"]
    override: false
    system:
      hostname_sources: ["os"]
      resource_attributes:
        host.id:
          enabled: true

connectors:
  metricsaslogs/oracle:
    include_resource_attributes: true
    include_scope_info: true

service:
  pipelines:
    metrics/oracledb:
      receivers: [newrelicoracledb/cdb1, newrelicoracledb/pdb1, newrelicoracledb/cdb2, newrelicoracledb/pdb2]
      processors: [memory_limiter/oracle, cumulativetodelta/oracle, transform/oracle_clear_metadata, filter/exec_plan_and_query_details_exclude, resourcedetection/oracle_db_safe]
      exporters: [otlp]

    metrics/oracle_query_to_logs:
      receivers: [newrelicoracledb/cdb1, newrelicoracledb/pdb1, newrelicoracledb/cdb2, newrelicoracledb/pdb2]
      processors: [memory_limiter/oracle, filter/exec_plan_and_query_details_include]
      exporters: [metricsaslogs/oracle]

    logs/oracledb:
      receivers: [metricsaslogs/oracle]
      processors: [memory_limiter/oracle, transform/oracle_clear_metadata, resourcedetection/oracle_db_safe]
      exporters: [otlp]

Conseil

Cette configuration vous permet de monitorer plusieurs instances Oracle RDS simultanément. Chaque instance dispose de sa propre configuration de récepteur avec des identifiants uniques, tout en partageant des processeurs et des exportateurs communs. Ajustez le collection_interval et d'autres paramètres en fonction de vos besoins de monitoring.
Redémarrez le collecteur NRDOT après avoir mis à jour la configuration pour appliquer les modifications.

(Facultatif) Configurer la corrélation APM-base de données

Pour corréler les performances de votre application avec les opérations de base de données, vous pouvez configurer l'identification du service de base de données. Cette fonctionnalité vous permet de voir exactement quelles applications génèrent des workloads de base de données spécifiques. Pour plus d'informations, reportez-vous à configurer l'identification du service de base de données pour obtenir la corrélation APM-base de données dans New Relic.

Important

Pour afficher les données de performance de la base de données dans APM, les deux entités doivent se trouver dans le même compte New Relic. Si les entités se trouvent dans des comptes New Relic différents, vous devez avoir accès aux deux comptes pour visualiser les données.

(Facultatif) Configurer la gestion des secrets

La fonctionnalité de gestion des secrets vous permet de gérer en toute sécurité des informations sensibles, telles que les identifiants de base de données. Cela permet de renforcer la sécurité de votre configuration de supervision en évitant de coder en dur des données sensibles dans les fichiers de configuration. Pour plus d'informations, consultez la gestion des secrets.

Trouvez et utilisez vos données

Une fois vos données collectées, vous pouvez accéder à un monitoring complet de la base de données Oracle via l'interface utilisateur de New Relic.

Pour trouver votre entité de base de données Oracle dans New Relic :

Allez à https://one.newrelic.com > All Capabilities > Databases.
Définissez les critères de recherche comme instrumentation.provider = opentelemetry.
Sélectionnez votre base de données Oracle dans la liste des entités.

Pour installer le collecteur NRDOT dans les environnements RDS, suivez ces étapes :

Méthode d'installation

Sélectionnez la méthode de distribution de l'installation appropriée pour votre environnement Linux :

Pour les systèmes Debian/Ubuntu, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-amd64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-amd64-latest.deb
$sudo dpkg -i nrdot-collector-host-linux-amd64-latest

Pour les systèmes RHEL/CentOS/OEL, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-amd64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-amd64-latest.rpm
$sudo rpm -ivh nrdot-collector-host-linux-amd64-latest

Pour les systèmes Debian/Ubuntu, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-arm64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-arm64-latest.deb
$sudo dpkg -i nrdot-collector-host-linux-arm64-latest

Pour les systèmes RHEL/CentOS/OEL, exécutez :

bash

$curl -L -o nrdot-collector-host-linux-arm64-latest https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-arm64-latest.rpm
$sudo rpm -ivh nrdot-collector-host-linux-arm64-latest

Configurer l'utilisateur de la base de données

Créez un utilisateur de monitoring avec les privilèges nécessaires pour votre base de données Oracle RDS.

Connectez-vous à la base de données racine en tant qu'administrateur :
```
CREATE USER <USERNAME> IDENTIFIED BY "<USER_PASSWORD>";
```
Accorder les privilèges CONNECT à l'utilisateur nouvellement créé :
```
GRANT CONNECT TO <USERNAME>;
```

Accorder des privilèges de monitoring pour la base de données RDS

Exécutez les instructions SQL suivantes pour accorder des privilèges de monitoring. Remplacez <USERNAME_IN_UPPERCASE> par votre nom d'utilisateur en majuscules :

SET SERVEROUTPUT ON;
BEGIN
    FOR r IN (SELECT column_value as view_name FROM table(sys.odcivarchar2list(
                'V_$SESSION', 'V_$SYSSTAT', 'V_$SESSTAT', 'V_$STATNAME', 
                'V_$SYSTEM_EVENT', 'V_$SHARED_SERVER', 'V_$DISPATCHER', 
                'V_$RESOURCE_LIMIT', 'V_$LOCK', 'V_$DATABASE', 
                'V_$PARAMETER', 'V_$SQLAREA', 'V_$SQL', 'V_$SQL_PLAN', 
                'V_$PDBS', 'GV_$INSTANCE', 'GV_$SGA', 'GV_$SESSTAT', 
                'GV_$STATNAME', 'GV_$SYSSTAT', 'GV_$SQLAREA', 
                'GV_$LIBRARYCACHE', 'GV_$ROWCACHE', 'GV_$PGASTAT', 
                'GV_$CONTAINERS', 'GV_$PDBS', 'GV_$CON_SYSMETRIC', 
                'GV_$SYSMETRIC', 'GV_$FILESTAT', 'GV_$SYSTEM_EVENT', 
                'GV_$ACTIVE_SERVICES', 'GV_$SESSION', 'GV_$SESSION_WAIT', 
                'GV_$ROLLSTAT', 'DBA_OBJECTS', 'DBA_TABLESPACES', 
                'DBA_TABLESPACE_USAGE_METRICS', 'DBA_DATA_FILES', 'DBA_USERS', 
                'CDB_SERVICES', 'CDB_DATA_FILES', 'CDB_TABLESPACE_USAGE_METRICS', 
                'CDB_USERS', 'CDB_PDBS', 'ALL_USERS', 'ALL_VIEWS', 'GLOBAL_NAME'
            ))) LOOP
      BEGIN
          rdsadmin.rdsadmin_util.grant_sys_object(
            p_obj_name  => r.view_name, 
            p_grantee   => '<USERNAME_IN_UPPERCASE>', 
            p_privilege => 'SELECT'
          );
      EXCEPTION 
          WHEN OTHERS THEN 
            DBMS_OUTPUT.PUT_LINE('FAILED: ' || r.view_name || ' | Error: ' || SQLERRM);
      END;
    END LOOP;
END;
/

Configurer le collecteur NRDOT

Modifiez votre fichier config.yaml disponible à /etc/nrdot-collector-host/, puis ajoutez l'extrait de code suivant :

Important

receivers:
  newrelicoracledb/pdb:
    endpoint: "<YOUR_DB_HOST>:<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    service: "<PDB_NAME>"
    collection_interval: 30s
    timeout: 30s
    # pdb_services: ['PDB1','PDB2'] #for multiple pdbs
    # query_monitoring_response_time_threshold: 500
    # query_monitoring_count_threshold: 30
    # enable_query_monitoring: true
    # enable_pdb_scraper: true
    # enable_tablespace_scraper: true
    # enable_core_scraper: true
    # enable_system_scraper: true
    # enable_connection_scraper: true
    # enable_container_scraper: true
    # enable_database_info_scraper: true
processors:
  transform/clear_metadata:
    metric_statements:
      - context: metric
        statements:
          - set(metric.description, "")
          - set(metric.unit, "")
    log_statements:
      - context: log
        statements:
          - set(log.body, "")
  filter/exec_plan_and_query_details_include:
    metrics:
      include:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details
  filter/exec_plan_and_query_details_exclude:
    metrics:
      exclude:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details
  cumulativetodelta:
    include:
      match_type: strict
      metrics:
        - newrelicoracledb.connection.bytes_received
        - newrelicoracledb.connection.bytes_sent
        - newrelicoracledb.connection.execute_count
        - newrelicoracledb.connection.logons_cumulative
        - newrelicoracledb.connection.parse_count_hard
        - newrelicoracledb.connection.parse_count_total
        - newrelicoracledb.connection.sqlnet_roundtrips
        - newrelicoracledb.connection.user_commits
        - newrelicoracledb.connection.user_rollbacks        
connectors:
  metricsaslogs:
    include_resource_attributes: true
    include_scope_info: true 
exporters:
  otlp:
    endpoint: "<YOUR_NEWRELIC_OTLP_ENDPOINT>" 
    headers:
      api-key: "<YOUR_NEWRELIC_API_KEY>"
    compression: gzip
service:
  pipelines:
    metrics:
      receivers: [newrelicoracledb/pdb]
      processors: [transform/clear_metadata, filter/exec_plan_and_query_details_exclude, cumulativetodelta]
      exporters: [otlp]
    metrics/exec_plan_and_query_details_to_logs:
      receivers: [newrelicoracledb/pdb]
      processors: [filter/exec_plan_and_query_details_include]
      exporters: [metricsaslogs]
    logs/newrelicoracledb:
      receivers: [metricsaslogs]
      processors: [transform/clear_metadata]
      exporters: [otlp]

Définissez les paramètres requis suivants dans le fichier de configuration :

paramètres	Description
`<YOUR_DB_HOST>`	Saisissez le nom d'hôte de votre base de données Oracle.
`<YOUR_DB_PORT>`	Saisissez le port de votre base de données Oracle.
`<USERNAME>`	Saisissez le nom d'utilisateur de votre base de données.
`<PASSWORD>`	Saisissez le mot de passe de votre base de données.
`<PDB_NAME>`	Saisissez le nom de votre service PDB.
`<YOUR_NEWRELIC_OTLP_ENDPOINT>`	Saisissez le point de terminaison OTLP New Relic. Pour plus d'informations, consultez la documentation sur les endpoints OTLP New Relic.
`<YOUR_NEWRELIC_API_KEY>`	Saisissez votre clé API New Relic.
`pdb_services`	Sélectionnez les services PDB à monitorer parmi les options suivantes : Vide ou nil : collecter uniquement les données de service spécifiées `["pdb1", "pdb2"]`: Collecter uniquement les services PDB spécifiés
`enable_query_monitoring`	Obtenez des métriques de monitoring des requêtes telles que les sessions lentes, actives, en attente et bloquantes, ainsi que le plan d'exécution. La valeur par défaut est définie sur `false`
`query_monitoring_response_time_threshold`	Définissez le seuil de temps de réponse des requêtes (en ms). Capture les requêtes qui dépassent ce seuil. La valeur par défaut est définie sur 500 ms.
`query_monitoring_count_threshold`	Le nombre d'enregistrements pour chaque métrique de performance des requêtes. La valeur par défaut est définie sur 30

Redémarrer le collecteur NRDOT

Après avoir mis à jour votre configuration, redémarrez le collecteur NRDOT :

bash

$sudo systemctl restart nrdot-collector-host
$sudo systemctl status nrdot-collector-host

Conseil

Redémarrez toujours le collecteur NRDOT après avoir modifié la configuration pour garantir la prise en compte des nouveaux paramètres.

(Facultatif) Configuration multi-récepteur

Le binaire nrdot-collector-host prend en charge une configuration multi-récepteur au sein d'un seul config.yaml pour monitorer plusieurs instances de base de données Oracle en utilisant des identifiants uniques. L'exemple config.yaml ci-dessous montre comment configurer plusieurs récepteurs pour différentes instances RDS tout en partageant des processeurs et des exportateurs communs.

receivers:
  # First RDS Instance
  newrelicoracledb/pdb/rds1:
    endpoint: "<YOUR_DB_HOST_1>:<YOUR_DB_PORT_1>"
    username: "<USERNAME_1>"
    password: "<PASSWORD_1>"
    service: "<PDB_NAME_1>"
    collection_interval: 30s
    timeout: 30s
    # query_monitoring_response_time_threshold: 500
    # query_monitoring_count_threshold: 30
    # enable_query_monitoring: true

  # Second RDS Instance
  newrelicoracledb/pdb/rds2:
    endpoint: "<YOUR_DB_HOST_2>:<YOUR_DB_PORT_2>"
    username: "<USERNAME_2>"
    password: "<PASSWORD_2>"
    service: "<PDB_NAME_2>"
    collection_interval: 30s
    timeout: 30s
    # query_monitoring_response_time_threshold: 500
    # query_monitoring_count_threshold: 30
    # enable_query_monitoring: true

processors:
  transform/clear_metadata:
    metric_statements:
      - context: metric
        statements:
          - set(metric.description, "")
          - set(metric.unit, "")
    log_statements:
      - context: log
        statements:
          - set(log.body, "")

  filter/exec_plan_and_query_details_include:
    metrics:
      include:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details

  filter/exec_plan_and_query_details_exclude:
    metrics:
      exclude:
        match_type: strict
        metric_names:
          - newrelicoracledb.execution_plan
          - newrelicoracledb.slow_queries.query_details

connectors:
  metricsaslogs:
    include_resource_attributes: true
    include_scope_info: true

exporters:
  otlp:
    endpoint: "<YOUR_NEWRELIC_OTLP_ENDPOINT>"
    headers:
      api-key: "<YOUR_NEWRELIC_API_KEY>"
    compression: gzip

service:
  pipelines:
    # Separate metrics pipelines to apply unique resource names
    metrics/rds1:
      receivers: [newrelicoracledb/pdb/rds1]
      processors: [transform/clear_metadata, filter/exec_plan_and_query_details_exclude]
      exporters: [otlp]
    
    metrics/rds2:
      receivers: [newrelicoracledb/pdb/rds2]
      processors: [transform/clear_metadata, filter/exec_plan_and_query_details_exclude]
      exporters: [otlp]

    # Combined logs pipeline for execution plans and query details
    metrics/exec_plan_and_query_details_to_logs:
      receivers: [newrelicoracledb/pdb/rds1, newrelicoracledb/pdb/rds2]
      processors: [filter/exec_plan_and_query_details_include]
      exporters: [metricsaslogs]

    logs/newrelicoracledb:
      receivers: [metricsaslogs]
      processors: [transform/clear_metadata]
      exporters: [otlp]

Conseil

Cette configuration vous permet de monitorer plusieurs instances Oracle RDS simultanément. Chaque instance dispose de sa propre configuration de récepteur avec des identifiants uniques, tout en partageant des processeurs et des exportateurs communs. Ajustez le collection_interval et d'autres paramètres en fonction de vos besoins de monitoring.
Redémarrez le collecteur NRDOT après avoir mis à jour la configuration pour appliquer les modifications.

(Facultatif) Configurer la corrélation APM-base de données

Important

Pour afficher les données de performance de la base de données dans APM, les deux entités doivent se trouver dans le même compte New Relic. Si les entités se trouvent dans des comptes différents, vous devez avoir accès aux deux comptes pour visualiser les données.

(Facultatif) Configurer la gestion des secrets

Trouvez et utilisez vos données

Une fois vos données collectées, vous pouvez accéder à un monitoring complet de la base de données Oracle via l'interface utilisateur de New Relic.

Pour trouver votre entité de base de données Oracle dans New Relic :

Allez à https://one.newrelic.com > All Capabilities > Databases.
Définissez les critères de recherche comme instrumentation.provider = opentelemetry.
Sélectionnez votre base de données Oracle dans la liste des entités.

Commandes prises en charge par le collecteur NRDOT

Cette section fournit une liste de commandes courantes pour gérer le service NRDOT Collector sur votre système.

Pour valider le statut de l'installation :
- Pour les distributions basées sur Debian/Ubuntu :
  bash
```
$dpkg -l | grep nrdot-collector-host
```
- Pour les distributions basées sur RHEL/CentOS :
  bash
```
$rpm -q nrdot-collector-host || ls /etc/nrdot-collector-host
```

Pour redémarrer NRDOT Collector :

bash

$sudo systemctl restart nrdot-collector-host

Pour vérifier l'état du NRDOT Collector :
bash
```
$sudo systemctl status nrdot-collector-host
```

Pour afficher les logs du NRDOT Collector :

bash

$sudo journalctl -u nrdot-collector-host -n 50 --no-pager

Pour supprimer le service NRDOT Collector :
- Pour les distributions basées sur Debian/Ubuntu :
  bash
```
$sudo apt purge nrdot-collector-host
```
- Pour les distributions basées sur RHEL/CentOS :
  bash
```
$sudo yum erase nrdot-collector-host
```

Pour nettoyer les fichiers de configuration :

bash

$# Clean up configuration and reload systemd
$sudo rm -rf /etc/nrdot-collector-host/
$sudo systemctl daemon-reload

Métriques disponibles

Monitorez les performances de votre base de données Oracle avec des métriques organisées par indicateurs de configuration. Les métriques par défaut sont collectées automatiquement pour les fonctionnalités de l'interface utilisateur New Relic. Vous pouvez également utiliser les métriques supplémentaires fournies pour obtenir des informations plus avancées et approfondies lorsque vous activez des scrapers spécifiques.

Métriques par défaut

Ces métriques sont essentielles pour les fonctionnalités de monitoring de base de données Oracle de New Relic et sont collectées automatiquement, quelle que soit votre configuration.

Nom métrique	Description
`newrelicoracledb.child_cursors.details`	Détails sur les curseurs enfants dans la base de données Oracle
`newrelicoracledb.child_cursors.elapsed_time`	Temps écoulé pour les opérations de curseur enfant
`newrelicoracledb.connection.active_sessions`	Nombre de sessions actives de la base de données Oracle
`newrelicoracledb.connection.execute_count`	Nombre d'exécutions SQL
`newrelicoracledb.connection.inactive_sessions`	Nombre de sessions de base de données Oracle inactives
`newrelicoracledb.connection.total_sessions`	Nombre total de sessions de base de données Oracle
`newrelicoracledb.memory.pga_max_size_bytes`	Limite de mémoire globale pour la PGA en octets
`newrelicoracledb.sessions.count`	Nombre total de sessions actives de la base de données Oracle
`newrelicoracledb.sga_hit_ratio`	Taux de réussite de la SGA (efficacité du cache tampon)
`newrelicoracledb.sga_shared_pool_library_cache_hit_ratio`	Taux de réussite du cache de bibliothèque pour l'espace de noms SQL AREA
`newrelicoracledb.slow_queries.execution_count`	Nombre d'exécutions de requêtes lentes
`newrelicoracledb.slow_queries.interval_avg_cpu_time`	Temps CPU moyen pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_avg_elapsed_time`	Temps écoulé moyen pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_buffer_gets`	Lectures de tampon pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_cpu_time`	Temps CPU pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_elapsed_time`	Temps écoulé pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_execution_count`	Nombre d'exécutions des requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_rows_processed`	Lignes traitées pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.interval_wait_time`	Temps d'attente pour les requêtes lentes dans l'intervalle
`newrelicoracledb.slow_queries.query_details`	Informations détaillées sur les requêtes lentes
`newrelicoracledb.slow_queries.total_cpu_time`	Temps CPU total pour les requêtes lentes
`newrelicoracledb.slow_queries.total_elapsed_time`	Temps écoulé total pour les requêtes lentes
`newrelicoracledb.slow_queries.total_rows_examined`	Nombre total de lignes examinées par les requêtes lentes
`newrelicoracledb.slow_queries.total_rows_returned`	Total des lignes renvoyées par les requêtes lentes
`newrelicoracledb.slow_queries.total_wait_time`	Temps d'attente total pour les requêtes lentes
`newrelicoracledb.system.average_active_sessions`	Moyenne des sessions actives simultanées
`newrelicoracledb.system.buffer_cache_hit_ratio`	Taux de réussite du cache de tampons
`newrelicoracledb.system.database_cpu_time_ratio`	Ratio du temps CPU de la base de données
`newrelicoracledb.system.enqueue_waits_per_second`	Taux de contention de mise en file d'attente
`newrelicoracledb.system.executions_per_second`	Taux d'exécution SQL
`newrelicoracledb.system.hard_parse_count_per_second`	Taux d'analyses inconditionnelles
`newrelicoracledb.system.host_cpu_utilization`	Pourcentage d'utilisation du CPU de l'hôte
`newrelicoracledb.system.io_megabytes_per_second`	Débit d'E/S en Mo/s
`newrelicoracledb.system.physical_reads_per_second`	Taux de lecture physique
`newrelicoracledb.system.physical_writes_per_second`	Taux d'écriture physique
`newrelicoracledb.system.redo_generated_bytes_per_second`	Taux de génération de redo
`newrelicoracledb.system.response_time_per_transaction`	temps de réponse par transaction
`newrelicoracledb.system.transactions_per_second`	Taux de transactions par seconde
`newrelicoracledb.wait_events.current_wait_time_ms`	Temps d'attente actuel pour les événements de base de données en millisecondes

Métriques supplémentaires

Activez ces métriques supplémentaires si nécessaire pour obtenir des informations plus approfondies sur les performances et l'état de santé de votre base de données Oracle.

Activez enable_tablespace_scraper: true pour collecter ces métriques :

Nom métrique	Description
`newrelicoracledb.tablespace.space_consumed_bytes`	Espace utilisé en octets par tablespace
`newrelicoracledb.tablespace.space_reserved_bytes`	Espace total alloué en octets par tablespace
`newrelicoracledb.tablespace.space_used_percentage`	Pourcentage d'utilisation par tablespace
`newrelicoracledb.tablespace.is_offline`	Statut hors ligne du tablespace (1=hors ligne, 0=en ligne)
`newrelicoracledb.tablespace.global_name`	Nom global de la base de données tagué par tablespace
`newrelicoracledb.tablespace.db_id`	ID de base de données étiqueté par tablespace
`newrelicoracledb.tablespace.offline_cdb_datafiles`	Nombre de fichiers de données hors ligne dans les tablespaces CDB
`newrelicoracledb.tablespace.offline_pdb_datafiles`	Nombre de fichiers de données hors ligne dans les tablespaces PDB
`newrelicoracledb.tablespace.pdb_non_write_mode`	Nombre de tablespaces PDB non en mode écriture

Activez enable_core_scraper: true pour collecter ces métriques :

Nom métrique	Description
`newrelicoracledb.memory.pga_in_use_bytes`	Mémoire PGA totale actuellement utilisée en octets
`newrelicoracledb.memory.pga_allocated_bytes`	Mémoire PGA totale allouée en octets
`newrelicoracledb.memory.pga_freeable_bytes`	Mémoire PGA totale libérable en octets
`newrelicoracledb.memory.sga_uga_total_bytes`	Mémoire totale SGA UGA en octets
`newrelicoracledb.memory.sga_shared_pool_library_cache_sharable_bytes`	Mémoire partageable du cache de bibliothèque du pool partagé SGA en octets
`newrelicoracledb.memory.sga_shared_pool_library_cache_user_bytes`	Mémoire partageable du cache de bibliothèque du pool partagé SGA par utilisateur en octets
`newrelicoracledb.sga_shared_pool_library_cache_reload_ratio`	Taux de rechargement du cache de bibliothèque (rechargements/épinglages)
`newrelicoracledb.sga_shared_pool_dict_cache_miss_ratio`	Taux d'échec du cache du dictionnaire (getmisses/gets)
`newrelicoracledb.sga_log_buffer_space_waits`	Nombre de sessions en attente d'espace de buffer de log
`newrelicoracledb.sga_log_allocation_retries_ratio`	Taux de nouvelles tentatives d'allocation de logs
`newrelicoracledb.sga_fixed_size_bytes`	Mémoire de taille fixe de la SGA en octets
`newrelicoracledb.sga_redo_buffers_bytes`	Mémoire des tampons de reprise SGA en octets
`newrelicoracledb.disk.reads`	Nombre de lectures de disque physique
`newrelicoracledb.disk.writes`	Nombre d'écritures sur le disque physique
`newrelicoracledb.disk.blocks_read`	Nombre de blocs physiques lus sur le disque
`newrelicoracledb.disk.blocks_written`	Nombre de blocs physiques écrits sur le disque
`newrelicoracledb.disk.read_time_milliseconds`	Temps passé à lire sur le disque en millisecondes
`newrelicoracledb.disk.write_time_milliseconds`	Temps passé à écrire sur le disque en millisecondes
`newrelicoracledb.global_name`	Informations sur le nom global de la base de données Oracle
`newrelicoracledb.db_id`	Informations sur l'identifiant de la base de données Oracle
`newrelicoracledb.locked_accounts`	Nombre de comptes utilisateur verrouillés dans la base de données
`newrelicoracledb.long_running_queries`	Nombre de requêtes de longue durée
`newrelicoracledb.sga_log_buffer_redo_allocation_retries`	Nombre de nouvelles tentatives d'allocation du tampon redo
`newrelicoracledb.sga_log_buffer_redo_entries`	Nombre d'entrées redo
`newrelicoracledb.sorts_memory`	Nombre de tris effectués en mémoire
`newrelicoracledb.sorts_disk`	Nombre de tris effectués sur disque
`newrelicoracledb.rollback_segments_gets`	Nombre d'acquisitions sur les segments d'annulation
`newrelicoracledb.rollback_segments_waits`	Nombre d'attentes sur les segments de rollback
`newrelicoracledb.rollback_segments_wait_ratio`	Taux d'attente des segments d'annulation (attentes/obtentions)
`newrelicoracledb.redo_log_parallel_write_waits`	Nombre d'attentes pour les événements d'écriture parallèle de fichier log
`newrelicoracledb.redo_log_switch_completion_waits`	Nombre d'attentes pour les événements de fin de basculement de fichier log
`newrelicoracledb.redo_log_switch_checkpoint_incomplete_waits`	Nombre d'attentes pour les événements de basculement de fichier log (point de contrôle incomplet)
`newrelicoracledb.redo_log_switch_archiving_needed_waits`	Nombre d'attentes pour les événements de basculement de fichier log (archivage nécessaire)
`newrelicoracledb.sga_buffer_busy_waits`	Nombre d'événements d'attente de mémoire tampon occupée
`newrelicoracledb.sga_free_buffer_waits`	Nombre d'événements d'attente de buffers libres
`newrelicoracledb.sga_free_buffer_inspected_waits`	Nombre d'événements d'attente de tampons libres inspectés

Activez enable_system_scraper: true pour collecter ces métriques :

Nom métrique	Description
`newrelicoracledb.system.active_parallel_sessions`	Sessions parallèles actives
`newrelicoracledb.system.active_serial_sessions`	Sessions série actives
`newrelicoracledb.system.background_checkpoints_per_second`	Points de contrôle en arrière-plan par seconde
`newrelicoracledb.system.background_cpu_usage_per_second`	Utilisation du CPU en arrière-plan par sec
`newrelicoracledb.system.background_time_per_second`	Temps d'arrière-plan par s
`newrelicoracledb.system.branch_node_splits_per_second`	Divisions de nœuds de branche par sec
`newrelicoracledb.system.branch_node_splits_per_transaction`	Scissions de nœuds de branche par txn
`newrelicoracledb.system.captured_user_calls`	Appels utilisateur capturés
`newrelicoracledb.system.consistent_read_changes_per_second`	Modifications de lecture cohérente par seconde
`newrelicoracledb.system.consistent_read_changes_per_transaction`	Changements de lecture cohérente par transaction
`newrelicoracledb.system.consistent_read_gets_per_second`	Lectures cohérentes par sec
`newrelicoracledb.system.consistent_read_gets_per_transaction`	Lectures cohérentes par txn
`newrelicoracledb.system.cpu_usage_per_second`	Utilisation du CPU par seconde
`newrelicoracledb.system.cpu_usage_per_transaction`	Utilisation du CPU par transaction
`newrelicoracledb.system.cr_blocks_created_per_second`	Blocs CR créés par seconde
`newrelicoracledb.system.cr_blocks_created_per_transaction`	Blocs CR créés par txn
`newrelicoracledb.system.cr_undo_records_applied_per_second`	Enregistrements d'annulation CR appliqués par seconde
`newrelicoracledb.system.cr_undo_records_applied_per_transaction`	Enregistrements d'annulation CR appliqués par txn
`newrelicoracledb.system.current_logons_count`	Nombre de connexions en cours
`newrelicoracledb.system.current_open_cursors_count`	Nombre actuel de curseurs ouverts
`newrelicoracledb.system.current_os_load`	Charge actuelle de l'OS
`newrelicoracledb.system.cursor_cache_hit_ratio`	Taux de réussite du cache de curseurs
`newrelicoracledb.system.database_time_per_second`	Temps de base de données par seconde
`newrelicoracledb.system.database_wait_time_ratio`	Ratio de temps d'attente de la base de données
`newrelicoracledb.system.db_block_changes_per_second`	Modifications de blocs de BD par seconde
`newrelicoracledb.system.db_block_changes_per_transaction`	Modifications de blocs de base de données par transaction
`newrelicoracledb.system.db_block_changes_per_user_call`	Modifications de blocs de base de données par appel utilisateur
`newrelicoracledb.system.db_block_gets_per_second`	Obtentions de blocs de base de données par seconde
`newrelicoracledb.system.db_block_gets_per_transaction`	Lectures de blocs BD par transaction
`newrelicoracledb.system.db_block_gets_per_user_call`	Lectures de blocs de BDD par appel utilisateur
`newrelicoracledb.system.dbwr_checkpoints_per_second`	Points de contrôle DBWR par seconde
`newrelicoracledb.system.disk_sort_per_second`	Tri sur disque par seconde
`newrelicoracledb.system.disk_sort_per_transaction`	Tri sur disque par transaction
`newrelicoracledb.system.enqueue_deadlocks_per_second`	Interblocages de mise en file d'attente par seconde
`newrelicoracledb.system.enqueue_deadlocks_per_transaction`	Interblocages d'enqueue par txn
`newrelicoracledb.system.enqueue_requests_per_second`	Requêtes de mise en file d'attente par s
`newrelicoracledb.system.enqueue_requests_per_transaction`	Requêtes de mise en file d'attente par transaction
`newrelicoracledb.system.enqueue_timeouts_per_second`	Délais d'attente de mise en file d'attente par seconde
`newrelicoracledb.system.enqueue_timeouts_per_transaction`	Délais d'attente de mise en file d'attente par txn
`newrelicoracledb.system.enqueue_waits_per_transaction`	Attentes de mise en file d'attente par txn
`newrelicoracledb.system.execute_without_parse_ratio`	Ratio d'exécution sans analyse
`newrelicoracledb.system.executions_per_transaction`	Exécutions par transaction
`newrelicoracledb.system.executions_per_user_call`	Exécutions par appel utilisateur
`newrelicoracledb.system.full_index_scans_per_second`	Analyses complètes d'index par seconde
`newrelicoracledb.system.full_index_scans_per_transaction`	Scans complets d'index par txn
`newrelicoracledb.system.gc_cr_block_received_per_second`	Blocs GC CR reçus par seconde (RAC)
`newrelicoracledb.system.gc_cr_block_received_per_transaction`	Blocs CR de cache global reçus par transaction (RAC)
`newrelicoracledb.system.gc_current_block_received_per_second`	Blocs courants GC reçus par sec (RAC)
`newrelicoracledb.system.gc_current_block_received_per_transaction`	Bloc courant GC reçu par txn (RAC)
`newrelicoracledb.system.global_cache_average_cr_get_time`	Temps moyen d'obtention CR du cache global (RAC)
`newrelicoracledb.system.global_cache_average_current_get_time`	Temps moyen d'obtention courante du cache global (RAC)
`newrelicoracledb.system.global_cache_blocks_corrupted`	Blocs du cache global corrompus (RAC)
`newrelicoracledb.system.global_cache_blocks_lost`	Blocs de cache global perdus (RAC)
`newrelicoracledb.system.hard_parse_count_per_transaction`	Nombre d'analyses complètes par transaction
`newrelicoracledb.system.host_cpu_usage_per_second`	Utilisation du CPU de l'hôte par seconde
`newrelicoracledb.system.io_requests_per_second`	Requêtes d'E/S par seconde
`newrelicoracledb.system.leaf_node_splits_per_second`	Scissions de nœuds feuilles par s
`newrelicoracledb.system.leaf_node_splits_per_transaction`	Divisions de nœuds feuilles par transaction
`newrelicoracledb.system.library_cache_hit_ratio`	Taux de réussite du cache de bibliothèque
`newrelicoracledb.system.library_cache_miss_ratio`	Taux d'échecs du cache de bibliothèque
`newrelicoracledb.system.logical_reads_per_second`	Lectures logiques par seconde
`newrelicoracledb.system.logical_reads_per_transaction`	Lectures logiques par transaction
`newrelicoracledb.system.logical_reads_per_user_call`	Lectures logiques par appel utilisateur
`newrelicoracledb.system.logons_per_second`	Connexions par seconde
`newrelicoracledb.system.logons_per_transaction`	Connexions par transaction
`newrelicoracledb.system.long_table_scans_per_second`	Analyses de table longues par seconde
`newrelicoracledb.system.long_table_scans_per_transaction`	Longs balayages de table par txn
`newrelicoracledb.system.memory_sorts_ratio`	Ratio de tris en mémoire
`newrelicoracledb.system.network_traffic_volume_per_second`	Volume du trafic réseau par seconde
`newrelicoracledb.system.open_cursors_per_second`	Curseurs ouverts par seconde
`newrelicoracledb.system.open_cursors_per_transaction`	Curseurs ouverts par transaction
`newrelicoracledb.system.parse_failure_count_per_second`	Nombre d'échecs d'analyse par seconde
`newrelicoracledb.system.parse_failure_count_per_transaction`	Nombre d'échecs d'analyse par transaction
`newrelicoracledb.system.pga_cache_hit_percentage`	Pourcentage de réussite du cache PGA
`newrelicoracledb.system.physical_lobs_reads_per_second`	Lectures physiques de LOBs par sec
`newrelicoracledb.system.physical_lobs_reads_per_transaction`	Lectures physiques de LOB par txn
`newrelicoracledb.system.physical_lobs_writes_per_second`	Écritures physiques de LOB par seconde
`newrelicoracledb.system.physical_lobs_writes_per_transaction`	Écritures physiques de LOB par transaction
`newrelicoracledb.system.physical_read_bytes_per_second`	Octets lus physiquement par seconde
`newrelicoracledb.system.physical_read_io_requests_per_second`	Requêtes d'E/S de lecture physique par seconde
`newrelicoracledb.system.physical_read_total_bytes_per_second`	Total d'octets de lecture physique par seconde
`newrelicoracledb.system.physical_read_total_io_requests_per_second`	Total des requêtes d'E/S de lecture physique par seconde
`newrelicoracledb.system.physical_reads_direct_per_second`	Lectures physiques directes par seconde
`newrelicoracledb.system.physical_reads_direct_per_transaction`	Lectures physiques directes par txn
`newrelicoracledb.system.physical_reads_per_transaction`	Lectures physiques par transaction
`newrelicoracledb.system.physical_write_bytes_per_second`	Octets d'écriture physique par seconde
`newrelicoracledb.system.physical_write_io_requests_per_second`	Requêtes d'E/S d'écriture physiques par seconde
`newrelicoracledb.system.physical_write_total_bytes_per_second`	Total d'octets d'écriture physique par seconde
`newrelicoracledb.system.physical_write_total_io_requests_per_second`	Total des requêtes d'E/S d'écriture physique par seconde
`newrelicoracledb.system.physical_writes_direct_per_second`	Écritures physiques directes par seconde
`newrelicoracledb.system.physical_writes_direct_per_transaction`	Écritures physiques directes par txn
`newrelicoracledb.system.physical_writes_per_transaction`	Écritures physiques par transaction
`newrelicoracledb.system.process_limit_percentage`	Pourcentage de la limite de processus
`newrelicoracledb.system.recursive_calls_per_second`	Appels récursifs par s
`newrelicoracledb.system.recursive_calls_per_transaction`	Appels récursifs par transaction
`newrelicoracledb.system.redo_allocation_hit_ratio`	Taux de réussite de l'allocation de redo
`newrelicoracledb.system.redo_generated_bytes_per_transaction`	Octets de reprise générés par transaction
`newrelicoracledb.system.redo_writes_per_second`	Écritures Redo par seconde
`newrelicoracledb.system.redo_writes_per_transaction`	Écritures Redo par txn
`newrelicoracledb.system.row_cache_hit_ratio`	Taux de réussite du cache de lignes
`newrelicoracledb.system.row_cache_miss_ratio`	Taux d'échec du cache de lignes
`newrelicoracledb.system.rows_per_sort`	Lignes par tri
`newrelicoracledb.system.session_count`	Nombre de sessions
`newrelicoracledb.system.session_limit_percentage`	Pourcentage de la limite de session
`newrelicoracledb.system.shared_pool_free_percentage`	Pourcentage libre du pool partagé
`newrelicoracledb.system.soft_parse_ratio`	Taux d'analyses logicielles
`newrelicoracledb.system.sql_service_response_time`	Temps de réponse du service SQL
`newrelicoracledb.system.streams_pool_usage_percentage`	Pourcentage d'utilisation du pool Streams
`newrelicoracledb.system.temp_space_used`	Espace temporaire utilisé
`newrelicoracledb.system.total_index_scans_per_second`	Total des analyses d'index par seconde
`newrelicoracledb.system.total_index_scans_per_transaction`	Total des scans d'index par transaction
`newrelicoracledb.system.total_parse_count_per_second`	Nombre total d'analyses par seconde
`newrelicoracledb.system.total_parse_count_per_transaction`	Nombre total d'analyses par transaction
`newrelicoracledb.system.total_sorts_per_user_call`	Total des tris par appel utilisateur
`newrelicoracledb.system.total_table_scans_per_second`	Total des balayages de table par seconde
`newrelicoracledb.system.total_table_scans_per_transaction`	Total des scans de table par transaction
`newrelicoracledb.system.total_table_scans_per_user_call`	Total des analyses de table par appel utilisateur
`newrelicoracledb.system.transactions_per_logon`	Transactions par connexion
`newrelicoracledb.system.transactions_per_second`	Transactions par seconde
`newrelicoracledb.system.user_calls_per_second`	Appels utilisateur par sec
`newrelicoracledb.system.user_calls_per_transaction`	Appels utilisateur par transaction
`newrelicoracledb.system.user_calls_ratio`	Ratio d'appels utilisateur
`newrelicoracledb.system.user_commits_percentage`	Pourcentage de commits utilisateur
`newrelicoracledb.system.user_limit_percentage`	Pourcentage de la limite d'utilisateurs
`newrelicoracledb.system.user_rollback_undo_records_applied_per_second`	Enregistrements d'annulation de rollback utilisateur appliqués par seconde
`newrelicoracledb.system.user_rollback_undo_records_applied_per_transaction`	Enregistrements d'annulation de rollback utilisateur appliqués par transaction
`newrelicoracledb.system.user_rollbacks_per_second`	Annulations utilisateur par seconde
`newrelicoracledb.system.user_rollbacks_percentage`	Pourcentage de rollbacks utilisateur

Activez enable_connection_scraper: true pour collecter ces métriques :

Nom métrique	Description
`newrelicoracledb.connection.sessions_by_status`	Nombre de sessions groupées par statut
`newrelicoracledb.connection.sessions_by_type`	Nombre de sessions regroupées par type
`newrelicoracledb.connection.logons_cumulative`	Nombre cumulé de connexions depuis le démarrage de l'instance
`newrelicoracledb.connection.logons_current`	Nombre actuel d'ouvertures de session actives
`newrelicoracledb.connection.shared_servers`	Nombre de serveurs partagés
`newrelicoracledb.connection.dispatchers`	Nombre de répartiteurs
`newrelicoracledb.connection.circuits`	Nombre de circuits actifs
`newrelicoracledb.connection.resource_current_utilization`	Utilisation actuelle des ressources Oracle
`newrelicoracledb.connection.resource_max_utilization`	Utilisation maximale des ressources Oracle depuis le démarrage
`newrelicoracledb.connection.resource_limit`	Valeur limite pour les ressources Oracle
`newrelicoracledb.connection.user_commits`	Nombre de commits utilisateur
`newrelicoracledb.connection.user_rollbacks`	Nombre de retours arrière utilisateur
`newrelicoracledb.connection.parse_count_total`	Nombre total d'appels d'analyse
`newrelicoracledb.connection.parse_count_hard`	Nombre d'appels d'analyse dure
`newrelicoracledb.connection.sqlnet_roundtrips`	Nombre d'allers-retours SQL*Net vers/depuis le client
`newrelicoracledb.connection.bytes_sent`	Octets envoyés au client via SQL*Net
`newrelicoracledb.connection.bytes_received`	Octets reçus via SQL*Net du client

Activez enable_pdb_scraper: true pour collecter ces métriques PDB (Pluggable Database) :

Nom métrique	Description
`newrelicoracledb.pdb.active_parallel_sessions`	Nombre de sessions parallèles actives dans la PDB
`newrelicoracledb.pdb.active_serial_sessions`	Nombre de sessions série actives dans la PDB
`newrelicoracledb.pdb.average_active_sessions`	Nombre moyen de sessions actives dans la PDB
`newrelicoracledb.pdb.background_cpu_usage_per_second`	Utilisation du CPU en arrière-plan par seconde dans la PDB
`newrelicoracledb.pdb.background_time_per_second`	Temps d'arrière-plan par seconde dans la PDB
`newrelicoracledb.pdb.block_changes_per_second`	Modifications de blocs de base de données par seconde dans la PDB
`newrelicoracledb.pdb.block_changes_per_transaction`	Modifications de blocs de base de données par transaction dans la PDB
`newrelicoracledb.pdb.cpu_time_ratio`	Ratio du temps CPU de la base de données dans la PDB
`newrelicoracledb.pdb.cpu_usage_per_second`	Utilisation du CPU par seconde dans la PDB
`newrelicoracledb.pdb.cpu_usage_per_transaction`	Utilisation du processeur par transaction dans la PDB
`newrelicoracledb.pdb.current_logons`	Nombre actuel de connexions dans la PDB
`newrelicoracledb.pdb.current_open_cursors`	Nombre actuel de curseurs ouverts dans la PDB
`newrelicoracledb.pdb.db_physical_read_bytes_per_second`	Octets de lecture physique par seconde dans la PDB
`newrelicoracledb.pdb.db_physical_reads_per_second`	Lectures physiques par seconde dans la PDB
`newrelicoracledb.pdb.db_physical_write_bytes_per_second`	Octets d'écriture physique par seconde dans la PDB
`newrelicoracledb.pdb.db_physical_writes_per_second`	Écritures physiques par seconde dans la PDB
`newrelicoracledb.pdb.execute_without_parse_ratio`	Taux d'exécutions sans analyse dans la PDB
`newrelicoracledb.pdb.executions_per_second`	Exécutions par seconde dans la PDB
`newrelicoracledb.pdb.executions_per_transaction`	Exécutions par transaction dans la PDB
`newrelicoracledb.pdb.hard_parse_count_per_second`	Nombre d'analyses dures par seconde dans la PDB
`newrelicoracledb.pdb.hard_parse_count_per_transaction`	Nombre d'analyses inconditionnelles par transaction dans la PDB
`newrelicoracledb.pdb.logical_reads_per_second`	Lectures logiques par seconde dans la PDB
`newrelicoracledb.pdb.logical_reads_per_transaction`	Lectures logiques par transaction dans la PDB
`newrelicoracledb.pdb.logons_per_second`	Connexions par seconde dans la PDB
`newrelicoracledb.pdb.logons_per_transaction`	Connexions par transaction dans la PDB
`newrelicoracledb.pdb.network_traffic_byte_per_second`	Volume du trafic réseau par seconde en octets dans la PDB
`newrelicoracledb.pdb.open_cursors_per_second`	Curseurs ouverts par seconde dans la PDB
`newrelicoracledb.pdb.open_cursors_per_transaction`	Curseurs ouverts par transaction dans la PDB
`newrelicoracledb.pdb.parse_failure_count_per_second`	Nombre d'échecs d'analyse par seconde dans la PDB
`newrelicoracledb.pdb.physical_read_bytes_per_second`	Total des octets de lecture physique par seconde dans la PDB
`newrelicoracledb.pdb.physical_reads_per_transaction`	Lectures physiques par transaction dans la PDB
`newrelicoracledb.pdb.physical_write_bytes_per_second`	Total d'octets d'écriture physique par seconde dans la PDB
`newrelicoracledb.pdb.physical_writes_per_transaction`	Écritures physiques par transaction dans la PDB
`newrelicoracledb.pdb.redo_generated_bytes_per_second`	Redo généré par seconde en octets dans la PDB
`newrelicoracledb.pdb.redo_generated_bytes_per_transaction`	Redo généré par transaction en octets dans la PDB
`newrelicoracledb.pdb.response_time_per_transaction`	Temps de réponse par transaction dans la PDB
`newrelicoracledb.pdb.session_count`	Nombre de sessions dans la PDB
`newrelicoracledb.pdb.soft_parse_ratio`	Taux d'analyses logicielles dans la PDB
`newrelicoracledb.pdb.sql_service_response_time`	Temps de réponse du service SQL dans la PDB
`newrelicoracledb.pdb.total_parse_count_per_second`	Nombre total d'analyses par seconde dans la PDB
`newrelicoracledb.pdb.total_parse_count_per_transaction`	Nombre total d'analyses par transaction dans la PDB
`newrelicoracledb.pdb.transactions_per_second`	Transactions utilisateur par seconde dans la PDB
`newrelicoracledb.pdb.user_calls_per_second`	Appels utilisateur par seconde dans la PDB
`newrelicoracledb.pdb.user_calls_per_transaction`	Appels utilisateur par transaction dans la PDB
`newrelicoracledb.pdb.user_commits_per_second`	Validations utilisateur par seconde dans la PDB
`newrelicoracledb.pdb.user_commits_percentage`	Pourcentage de commits utilisateur dans la PDB
`newrelicoracledb.pdb.user_rollbacks_per_second`	Annulations utilisateur par seconde dans la PDB
`newrelicoracledb.pdb.user_rollbacks_percentage`	Pourcentage d'annulations utilisateur dans la PDB
`newrelicoracledb.pdb.wait_time_ratio`	Ratio du temps d'attente de la base de données dans la PDB

Activez enable_container_scraper: true pour collecter ces métriques de conteneur pour les environnements CDB :

Nom métrique	Description
`newrelicoracledb.container.status`	Statut du mode d'ouverture du conteneur (1=LECTURE ÉCRITURE 0=autre)
`newrelicoracledb.container.restricted`	Mode restreint du conteneur (1=OUI 0=NON)
`newrelicoracledb.pdb.open_mode`	Mode d'ouverture PDB (1=LECTURE ÉCRITURE 0=autre)
`newrelicoracledb.pdb.total_size_bytes`	Taille totale de la PDB en octets
`newrelicoracledb.tablespace.used_bytes`	Octets utilisés par tablespace dans la CDB
`newrelicoracledb.tablespace.total_bytes`	Total des octets par tablespace dans la CDB
`newrelicoracledb.tablespace.used_percent`	Pourcentage d'utilisation par tablespace dans la CDB
`newrelicoracledb.datafile.size_bytes`	Taille du fichier de données en octets
`newrelicoracledb.datafile.used_bytes`	Octets utilisés dans le fichier de données
`newrelicoracledb.datafile.autoextensible`	Statut autoextensible du fichier de données (1=OUI 0=NON)
`newrelicoracledb.service.status`	Statut du service Oracle (1=actif 0=inactif)
`newrelicoracledb.service.count`	Nombre de services par conteneur

Activez enable_rac_scraper: true pour collecter ces métriques RAC (Real Application Clusters) :

Nom métrique	Description
`newrelicoracledb.asm.diskgroup.total_mb`	Capacité totale du groupe de disques ASM en Mo
`newrelicoracledb.asm.diskgroup.free_mb`	Espace libre disponible dans le groupe de disques ASM en Mo
`newrelicoracledb.asm.diskgroup.offline_disks`	Nombre de disques hors ligne dans le groupe de disques ASM
`newrelicoracledb.rac.wait_time`	Taux de temps d'attente du cluster en microsecondes par seconde
`newrelicoracledb.rac.total_waits`	Nombre total d'événements d'attente de cluster
`newrelicoracledb.rac.instance.status`	Statut de l'instance RAC (1=OUVERT 0=autre)
`newrelicoracledb.rac.instance.uptime_seconds`	Durée de fonctionnement de l'instance en secondes depuis le démarrage
`newrelicoracledb.rac.instance.database_status`	Indicateur d'état de la base de données (1=ACTIF 0=autre)
`newrelicoracledb.rac.instance.active_state`	Indicateur d'état actif de l'instance (1=NORMAL 0=autre)
`newrelicoracledb.rac.instance.logins_allowed`	Indicateur de statut de connexion de l'instance (1=AUTORISÉ 0=RESTREINT)
`newrelicoracledb.rac.instance.archiver_started`	Indicateur d'état de l'archiveur (1=DÉMARRÉ 0=ARRÊTÉ)
`newrelicoracledb.rac.instance.version_info`	Informations sur la version de la base de données Oracle (toujours 1 version dans les attributs)
`newrelicoracledb.rac.service.instance_id`	ID de l'instance sur laquelle le service s'exécute actuellement
`newrelicoracledb.rac.service.network_config`	Configuration du réseau de services (toujours 1 configuration dans les attributs)
`newrelicoracledb.rac.service.clb_config`	Configuration de l'équilibrage de charge des connexions (toujours 1 configuration dans les attributs)
`newrelicoracledb.rac.service.goal_config`	Configuration de l'objectif de service (toujours 1 objectif dans les attributs)
`newrelicoracledb.rac.service.blocked_status`	Indicateur de service bloqué (1=bloqué 0=non bloqué)
`newrelicoracledb.rac.service.fan_enabled`	Indicateur d'activation Fast Application Notification (FAN) (1=activé 0=désactivé)
`newrelicoracledb.rac.service.transaction_guard_enabled`	Indicateur d'activation de Transaction Guard (1=activé 0=désactivé)
`newrelicoracledb.rac.service.drain_timeout_seconds`	Délai de vidage de session en secondes avant l'arrêt du service
`newrelicoracledb.rac.service.replay_timeout_seconds`	Délai d'attente de l'initiation du rejeu Application Continuity en secondes

Activez enable_database_info_scraper: true pour collecter ces métriques d'informations sur la base de données :

Nom métrique	Description
`newrelicoracledb.database.info`	Informations sur la version et la configuration de la base de données
`newrelicoracledb.hosting.info`	Hébergement de bases de données et informations sur la plateforme
`newrelicoracledb.database.role`	Rôle de la base de données et configuration Data Guard

Activez enable_query_monitoring: true pour collecter ces métriques de monitoring des requêtes lentes :

Nom métrique	Description
`newrelicoracledb.slow_queries.execution_count`	Nombre d'exécutions des requêtes lentes
`newrelicoracledb.slow_queries.total_elapsed_time`	Temps écoulé cumulé total pour les requêtes lentes
`newrelicoracledb.slow_queries.total_cpu_time`	Temps CPU cumulé total pour les requêtes lentes
`newrelicoracledb.slow_queries.total_wait_time`	Temps d'attente cumulé total pour les requêtes lentes (elapsed_time - cpu_time)
`newrelicoracledb.slow_queries.total_rows_examined`	Total cumulé de lignes examinées pour les requêtes lentes (buffer gets/lectures logiques)
`newrelicoracledb.slow_queries.total_rows_returned`	Total cumulé des lignes renvoyées pour les requêtes lentes (lignes traitées)
`newrelicoracledb.slow_queries.total_disk_reads`	Total cumulé des lectures disque pour les requêtes lentes
`newrelicoracledb.slow_queries.total_disk_writes`	Total cumulé des écritures directes pour les requêtes lentes - écritures contournant le cache tampon
`newrelicoracledb.slow_queries.interval_execution_count`	Nombre de nouvelles exécutions depuis la dernière collecte (métrique delta)
`newrelicoracledb.slow_queries.interval_elapsed_time`	Temps total écoulé au cours du dernier intervalle d'interrogation (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_cpu_time`	Temps CPU total durant le dernier intervalle de collecte (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_wait_time`	Temps d'attente total au cours du dernier intervalle d'interrogation (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_buffer_gets`	Total des lectures de tampon (lectures logiques) au cours du dernier intervalle d'interrogation (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_rows_processed`	Total des lignes traitées (renvoyées) au cours du dernier intervalle d'interrogation (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_disk_reads`	Total des lectures disque au cours du dernier intervalle d'interrogation (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_disk_writes`	Total des écritures directes au cours du dernier intervalle d'interrogation - écritures contournant le cache tampon (métrique delta non moyennée)
`newrelicoracledb.slow_queries.interval_avg_elapsed_time`	Temps écoulé moyen par exécution au cours du dernier intervalle d'interrogation (métrique delta)
`newrelicoracledb.slow_queries.interval_avg_cpu_time`	Temps CPU moyen par exécution au cours du dernier intervalle d'interrogation (métrique delta)
`newrelicoracledb.slow_queries.interval_avg_wait_time`	Temps d'attente moyen par exécution au cours du dernier intervalle de sondage (métrique delta)
`newrelicoracledb.slow_queries.interval_avg_buffer_gets`	Moyenne des lectures de tampon (lectures logiques) par exécution au cours du dernier intervalle de collecte (métrique delta)
`newrelicoracledb.slow_queries.interval_avg_rows_processed`	Nombre moyen de lignes traitées (renvoyées) par exécution au cours du dernier intervalle d'interrogation (métrique delta)
`newrelicoracledb.slow_queries.interval_avg_disk_reads`	Moyenne des lectures disque par exécution au cours du dernier intervalle d'interrogation (métrique delta)
`newrelicoracledb.slow_queries.interval_avg_disk_writes`	Moyenne des écritures directes par exécution au cours du dernier intervalle d'interrogation - écritures contournant le cache tampon (métrique delta)
`newrelicoracledb.slow_queries.query_details`	Nombre de détails de requêtes lentes
`newrelicoracledb.child_cursors.elapsed_time`	Temps écoulé moyen par exécution pour ce curseur enfant (en millisecondes)
`newrelicoracledb.child_cursors.cpu_time`	Temps CPU moyen par exécution pour ce curseur enfant (en millisecondes)
`newrelicoracledb.child_cursors.user_io_wait_time`	Temps d'attente moyen des E/S utilisateur par exécution pour ce curseur enfant (en millisecondes)
`newrelicoracledb.child_cursors.buffer_gets`	Nombre moyen de lectures de tampon par exécution pour ce curseur enfant
`newrelicoracledb.child_cursors.disk_reads`	Nombre moyen de lectures disque par exécution pour ce curseur enfant
`newrelicoracledb.child_cursors.executions`	Nombre total d'exécutions de ce curseur enfant
`newrelicoracledb.child_cursors.invalidations`	Nombre de fois que ce curseur enfant a été invalidé
`newrelicoracledb.child_cursors.details`	Détails du curseur enfant incluant les temps de chargement
`newrelicoracledb.execution_plan`	Détails du plan d'exécution SQL Oracle incluant les coûts d'opération, la cardinalité et les estimations de ressources

Et ensuite ?

Après avoir configuré le monitoring de base de données Oracle avec NRDOT :

Créez des dashboards personnalisés pour visualiser les métriques de votre base de données
Configurer des alertes pour les seuils critiques de performances des bases de données
Explorez vos données à l'aide des fonctionnalités de requête de New Relic

Cette traduction automatique est fournie pour votre commodité.

Monitoring d'Oracle Database avec NRDOT

Aperçu

Prérequis .css-21sua1{background:none;border:none;width:0;padding:0;}

Configurer le NRDOT Collector pour le monitoring d'Oracle Database

Conseil

Méthode d'installation

Important

Pour l'architecture ARM64

Configurer l'utilisateur de la base de données

Conseil

Accorder des privilèges de monitoring pour une base de données multitenant

Configurer le collecteur NRDOT

Important

Conseil

Redémarrer le collecteur NRDOT

Conseil

(Facultatif) Configuration multi-récepteur

Conseil

(Facultatif) Configurer la corrélation APM-base de données

Important

(Facultatif) Configurer la gestion des secrets

Trouvez et utilisez vos données

Méthode d'installation

Pour l'architecture AMD64

Pour l'architecture ARM64

Configurer l'utilisateur de la base de données

Accorder des privilèges de monitoring pour la base de données RDS

Configurer le collecteur NRDOT

Important

Redémarrer le collecteur NRDOT

Conseil

(Facultatif) Configuration multi-récepteur

Conseil

(Facultatif) Configurer la corrélation APM-base de données

Important

(Facultatif) Configurer la gestion des secrets

Trouvez et utilisez vos données

Commandes prises en charge par le collecteur NRDOT

Commandes du collecteur NRDOT

Métriques disponibles

Métriques par défaut

Métriques par défaut collectées par le collecteur NRDOT

Métriques supplémentaires

Métriques de l'espace de table

Métriques principales

Métriques système

Métriques de connexion

Métriques PDB

conteneurs métriques

Métriques RAC

Métriques d'informations de base de données

Interroger les métriques de monitoring

Et ensuite ?

Prérequis