Supervision de Microsoft SQL Server 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 Microsoft SQL Server à 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 fournit des informations complètes 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
Versions de base de données prises en charge : SQL Server 2017 ou version ultérieure
Configuration de la base de données SQL Server :
- Accès administrateur à votre instance SQL Server (rôle sysadmin ou équivalent)
- Microsoft SQL Server qui prend en charge les instances gérées sur site
- Connectivité réseau entre le collecteur NRDOT et votre serveur SQL
- SQL Server Management Studio (SSMS) ou l'utilitaire sqlcmd
- Nom d'hôte ou adresse IP du serveur
- Numéro de port (généralement 1433) ou port personnalisé
- Authentification de domaine Windows ou SQL Server
- Préférence SSL
Configuration requise :
- Système Windows ou Linux pour exécuter le collecteur NRDOT
- Connectivité réseau vers le point de terminaison OTLP de New Relic

Configurer le collecteur NRDOT pour le monitoring de Microsoft SQL Server

Vous pouvez utiliser le collecteur NRDOT pour monitorer vos bases de données Microsoft SQL Server. Le collecteur NRDOT est une distribution préconfigurée qui inclut des composants spécifiques à New Relic.

Pour installer et configurer le NRDOT Collector, suivez ces étapes :

Configurer le collecteur NRDOT

Installez le collecteur en fonction de votre système d'exploitation et de votre architecture.

Important

Il est recommandé d'installer le NRDOT Collector sur le même hôte que votre instance SQL Server afin de visualiser les métriques d'infrastructure pour le monitoring des performances des requêtes.

Téléchargez et exécutez le programme d'installation en collant cette URL dans votre navigateur pour télécharger le programme d'installation de l'intégration NRDOT Collector de New Relic.
```
https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-windows-amd64-latest.msi
```
Localisez votre fichier téléchargé et double-cliquez dessus pour installer le NRDOT Collector.

Pour l'architecture AMD64 :
- Pour les distributions basées sur Debian/Ubuntu :
  bash
```
$curl -L -o nrdot-collector-host-linux-amd64.deb https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-amd64-latest.deb
$sudo dpkg -i nrdot-collector-host-linux-amd64.deb
```
- Pour les distributions basées sur RHEL/CentOS :
  bash
```
$curl -L -o nrdot-collector-host-linux-amd64.rpm https://download.newrelic.com/database-monitoring/nrdot-collector/nrdot-collector-host-linux-amd64-latest.rpm 
$sudo rpm -ivh nrdot-collector-host-linux-amd64.rpm
```

Pour l'architecture ARM64 :

Pour les distributions basées sur Debian/Ubuntu :

bash

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

Pour les distributions basées sur RHEL/CentOS :

bash

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

Configurer l'utilisateur de la base de données

Exécutez le script suivant en tant que root user/sysadmin pour créer l'utilisateur de monitoring newrelic et accorder des droits de lecture globaux.

Pour créer un utilisateur de monitoring newrelic, exécutez le script suivant à l'aide de SQL Server Management Studio (SSMS) :

USE [master];
GO
CREATE LOGIN [newrelic] WITH PASSWORD = '<PASSWORD>';
GO
-- Instance-level permissions
GRANT VIEW SERVER STATE TO [newrelic];
GRANT VIEW ANY DEFINITION TO [newrelic];
GRANT VIEW ANY DATABASE TO [newrelic];
GO
-- Grant read access privileges to all user databases
DECLARE @name SYSNAME;
DECLARE db_cursor CURSOR READ_ONLY FORWARD_ONLY FOR
SELECT [name]
FROM [master].[sys].[databases]
WHERE [name] NOT IN ('master', 'msdb', 'tempdb', 'model', 'rdsadmin', 'distribution')
AND [state] = 0; -- Only online databases
OPEN db_cursor;
FETCH NEXT FROM db_cursor INTO @name;
WHILE @@FETCH_STATUS = 0
BEGIN
  BEGIN TRY
    PRINT 'Processing database: ' + @name;
    EXEC('USE [' + @name + '];
    IF NOT EXISTS (SELECT 1 FROM sys.database_principals WHERE name = ''newrelic'')
    BEGIN
      CREATE USER [newrelic] FOR LOGIN [newrelic];
    END;
    GRANT VIEW DATABASE STATE TO [newrelic];
    GRANT VIEW DEFINITION TO [newrelic];
    ALTER ROLE db_datareader ADD MEMBER [newrelic];');
    PRINT 'Success: ' + @name;
  END TRY
  BEGIN CATCH
    PRINT 'Error on ' + @name + ': ' + ERROR_MESSAGE();
  END CATCH
  FETCH NEXT FROM db_cursor INTO @name;
END
CLOSE db_cursor;
DEALLOCATE db_cursor;
GO

Pour créer un utilisateur de monitoring newrelic sous Linux, créez un fichier nommé nr-grant-permission.sql sur votre instance Linux avec le contenu suivant :

USE [master];
GO
CREATE LOGIN [newrelic] WITH PASSWORD = '<PASSWORD>';
GO
-- Instance-level permissions
GRANT VIEW SERVER STATE TO [newrelic];
GRANT VIEW ANY DEFINITION TO [newrelic];
GRANT VIEW ANY DATABASE TO [newrelic];
GO
-- Grant read access privileges to all user databases
DECLARE @name SYSNAME;
DECLARE db_cursor CURSOR READ_ONLY FORWARD_ONLY FOR
SELECT [name]
FROM [master].[sys].[databases]
WHERE [name] NOT IN ('master', 'msdb', 'tempdb', 'model', 'rdsadmin', 'distribution')
AND [state] = 0; -- Only online databases
OPEN db_cursor;
FETCH NEXT FROM db_cursor INTO @name;
WHILE @@FETCH_STATUS = 0
BEGIN
  BEGIN TRY
    PRINT 'Processing database: ' + @name;
    EXEC('USE [' + @name + '];
    IF NOT EXISTS (SELECT 1 FROM sys.database_principals WHERE name = ''newrelic'')
    BEGIN
      CREATE USER [newrelic] FOR LOGIN [newrelic];
    END;
    GRANT VIEW DATABASE STATE TO [newrelic];
    GRANT VIEW DEFINITION TO [newrelic];
    ALTER ROLE db_datareader ADD MEMBER [newrelic];');
    PRINT 'Success: ' + @name;
  END TRY
  BEGIN CATCH
    PRINT 'Error on ' + @name + ': ' + ERROR_MESSAGE();
  END CATCH
  FETCH NEXT FROM db_cursor INTO @name;
END
CLOSE db_cursor;
DEALLOCATE db_cursor;
GO

Pour exécuter le script, exécutez la commande suivante. Remplacez <Your_SA_Password> par votre mot de passe administrateur SQL Server :
bash
```
$sqlcmd -S localhost -U sa -P '<Your_SA_Password>' -C -i nr-grant-permission.sql
```

(Facultatif) Pour vérifier que l'utilisateur a été créé avec succès et dispose des autorisations appropriées, exécutez la commande suivante. Remplacez <Your_SA_Password> par votre mot de passe administrateur SQL Server :

bash

$sqlcmd -S localhost -U sa -P '<Your_SA_Password>' -C -Q "SELECT sp.name AS [User], p.permission_name AS [Permission_Granted] FROM sys.server_permissions p JOIN sys.server_principals sp ON p.grantee_principal_id = sp.principal_id WHERE sp.name = 'newrelic';"

Résultat attendu :

User Permission_Granted
---------------------------------------------------------------------------------------------
<your_username> CONNECT SQL
<your_username> VIEW ANY DEFINITION
<your_username> VIEW ANY DATABASE
<your_username> VIEW SERVER STATE

Cette sortie confirme que votre utilisateur a été créé avec succès avec les permissions requises au niveau du serveur.

Configurer le collecteur NRDOT

Remplacez votre config.yaml par le contenu ci-dessous :

Windows: C:\Program Files (x86)\NRDOT Collector Host\config.yaml

Linux: /etc/nrdot-collector-host/config.yaml

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 de la base de données MSSQL tout en conservant vos configurations actuelles.

# NRDOT Collector Configuration for New Relic SQL Server Integration
# SQL Server On-Premises/VM Configuration

extensions:
  health_check:

receivers:
  otlp:
    protocols:
      grpc:
      http:

  hostmetrics:
    # Default collection interval is 60s. Lower if you need finer granularity.
    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

  newrelicsqlserver:
    hostname: "<YOUR_DB_HOST>"
    port: "<YOUR_DB_PORT>"
    username: "<USERNAME>"
    password: "<PASSWORD>"
    monitored_databases: []
    # timeout: 30s
    # collection_interval: 15s  
    # query_monitoring_fetch_interval: 15
    # query_monitoring_response_time_threshold: 100
    # query_monitoring_count_threshold: 30
    # interval_calculator_cache_ttl_minutes: 10

    # Metric Category Toggles - Enable/disable entire categories of metrics
    # enable_instance_metrics: true
    # enable_database_metrics: true
    # enable_user_connection_metrics: true
    # enable_wait_time_metrics: true
    # enable_failover_cluster_metrics: true
    # enable_database_principals_metrics: true
    # enable_database_role_membership_metrics: true
    # enable_security_metrics: true
    # enable_lock_metrics: true
    # enable_thread_pool_metrics: true
    # enable_tempdb_metrics: true

processors:
  # group system.cpu metrics by cpu
  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

  # remove system.cpu metrics for states
  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 to clear description and unit fields
  transform/clear_metadata:
    metric_statements:
      - context: metric
        statements:
          - set(metric.description, "")
          - set(metric.unit, "")

  # Filter to only include execution plan and event metrics (for logs conversion)
  filter/exec_plan_include:
    metrics:
      include:
        match_type: strict
        metric_names:
          - sqlserver.slowquery.query_details
          - sqlserver.execution.plan
          - sqlserver.blocking_query.details
          - sqlserver.activequery.query_details

  # Filter to exclude execution plan and event metrics (from main metrics pipeline)
  filter/exec_plan_exclude:
    metrics:
      exclude:
        match_type: strict
        metric_names:
          - sqlserver.slowquery.query_details
          - sqlserver.execution.plan
          - sqlserver.blocking_query.details
          - sqlserver.activequery.query_details

  cumulativetodelta:
    max_staleness: 5m
    include:
      match_type: strict
      metrics:
        # Wait stats (sys.dm_os_wait_stats)
        - sqlserver.wait_stats.latch.wait_time_ms
        - sqlserver.wait_stats.latch.waiting_tasks_count
        - sqlserver.wait_stats.wait_time_ms
        - sqlserver.wait_stats.waiting_tasks_count
        # Instance stats (sys.dm_os_performance_counters)
        - sqlserver.stats.sql_compilations_per_sec
        - sqlserver.stats.sql_recompilations_per_sec
        - sqlserver.stats.lock_waits_per_sec
        - sqlserver.stats.deadlocks_per_sec
        - sqlserver.stats.user_errors_per_sec
        - sqlserver.stats.kill_connection_errors_per_sec
        - sqlserver.access.page_splits_per_sec
        - sqlserver.buffer.checkpoint_pages_per_sec
        - sqlserver.bufferpool.batch_requests_per_sec
        - sqlserver.instance.transactions_per_sec
        - sqlserver.instance.forced_parameterizations_per_sec
        - sqlserver.instance.full_scans_rate
        - sqlserver.instance.lock_timeouts_rate
        # Database log (sys.dm_os_performance_counters)
        - sqlserver.database.log.flushes_per_sec
        - sqlserver.database.log.bytes_flushed_per_sec
        - sqlserver.database.log.flush_waits_per_sec
        # Failover cluster
        - sqlserver.failover_cluster.log_bytes_received_per_sec
        # User connections
        - sqlserver.user_connections.authentication.logins_per_sec

  deltatorate:
    metrics:
      - sqlserver.wait_stats.latch.wait_time_ms
      - sqlserver.wait_stats.latch.waiting_tasks_count
      - sqlserver.wait_stats.wait_time_ms
      - sqlserver.wait_stats.waiting_tasks_count
      - sqlserver.stats.sql_compilations_per_sec
      - sqlserver.stats.sql_recompilations_per_sec
      - sqlserver.stats.lock_waits_per_sec
      - sqlserver.stats.deadlocks_per_sec
      - sqlserver.stats.user_errors_per_sec
      - sqlserver.stats.kill_connection_errors_per_sec
      - sqlserver.access.page_splits_per_sec
      - sqlserver.buffer.checkpoint_pages_per_sec
      - sqlserver.bufferpool.batch_requests_per_sec
      - sqlserver.instance.transactions_per_sec
      - sqlserver.instance.forced_parameterizations_per_sec
      - sqlserver.instance.full_scans_rate
      - sqlserver.instance.lock_timeouts_rate
      - sqlserver.database.log.flushes_per_sec
      - sqlserver.database.log.bytes_flushed_per_sec
      - sqlserver.database.log.flush_waits_per_sec
      - sqlserver.failover_cluster.log_bytes_received_per_sec
      - sqlserver.user_connections.authentication.logins_per_sec

  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)

  # used to prevent out of memory situations on the collector
  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:
  otlphttp:
    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/db_safe
        - resourcedetection/env
        - cumulativetodelta
        - deltatorate
        - batch
      exporters: [otlphttp]
    traces:
      receivers: [otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, batch]
      exporters: [otlphttp]
    metrics:
      receivers: [newrelicsqlserver, otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, filter/exec_plan_exclude, batch]
      exporters: [otlphttp]
    logs:
      receivers: [metricsaslogs, otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, batch]
      exporters: [otlphttp]
    metrics/exec_plan_to_logs:
      receivers: [newrelicsqlserver, otlp]
      processors: [memory_limiter, transform, resourcedetection, resourcedetection/cloud, resourcedetection/env, filter/exec_plan_include, batch]
      exporters: [metricsaslogs]
  extensions: [health_check]

Paramètres de configuration

Le tableau suivant décrit les principaux paramètres de configuration du récepteur newrelicsqlserver :

paramètres	Description
`<YOUR_DB_HOST>`	Saisissez le nom d'hôte ou l'adresse IP de SQL Server
`<YOUR_DB_PORT>`	Saisissez votre numéro de port SQL Server. La valeur par défaut est définie sur 1433.
`<USERNAME>`	Saisissez votre nom d'utilisateur de base de données pour l'authentification
`<PASSWORD>`	Saisissez le mot de passe de votre base de données pour l'authentification
`<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.
`query_monitoring_response_time_threshold`	Temps de réponse minimum en millisecondes pour considérer une requête comme lente. La valeur par défaut est définie sur `100` ms.
`query_monitoring_count_threshold`	Nombre minimal d'exécutions pour inclure une requête dans le monitoring. La valeur par défaut est définie sur `30` .
`query_monitoring_fetch_interval`	Intervalle en secondes pour récupérer les données de monitoring des requêtes. La valeur par défaut est définie sur `15` secondes.
`collection_interval`	Intervalle en secondes pour collecter les métriques. La valeur par défaut est définie sur `15s` .

Redémarrer le collecteur NRDOT

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

Pour Windows, pour redémarrer le service NRDOT Collector, exécutez :
bash
```
$net stop nrdot-collector-host
$net start nrdot-collector-host
```
Pour Linux, pour redémarrer le service NRDOT Collector, exécutez :
bash
```
$sudo systemctl restart nrdot-collector-host
```
Conseil
Redémarrez toujours le service de collecte NRDOT après avoir modifié la configuration pour vous assurer que les nouveaux paramètres soient pris en compte.

(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 des bases de données SQL Server via l'interface utilisateur de New Relic.

Pour trouver votre entité de base de données SQL Server 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 SQL Server dans la liste des entités.

Commandes prises en charge par le collecteur NRDOT

Pour gérer le service NRDOT Collector, consulter les logs ou vérifier l'état du service, utilisez les commandes disponibles suivantes selon votre système d'exploitation.

Pour redémarrer NRDOT Collector :

bash

$net stop nrdot-collector-host
$net start nrdot-collector-host

Pour vérifier l'état du NRDOT Collector :
bash
```
$sc query nrdot-collector-host
```
Pour afficher les logs du NRDOT Collector :
1. Saisissez Event Viewer dans la barre de recherche et sélectionnez-le.
2. Dans la barre latérale gauche, développez le dossier nommé Windows Logs.
3. Cliquez sur Application pour charger les événements spécifiques à l'application dans le volet central.
4. Rechercher des événements avec le type de source = nrdot-collector-host
Pour supprimer le service NRDOT Collector, désinstallez-le via Add/Remove Programs.

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 -f
```
Pour supprimer le service NRDOT Collector :
- Pour les distributions basées sur Debian/Ubuntu :
  bash
```
$sudo apt-get purge -y nrdot-collector-host
```
- Pour les distributions basées sur RHEL/CentOS :
  bash
```
$sudo dnf remove -y nrdot-collector-host&& sudo rm -rf /etc/nrdot-collector-host
```

Dépannage

Si vous rencontrez des problèmes de connectivité réseau avec le collecteur NRDOT, exécutez les commandes suivantes pour tester la connectivité vers votre instance SQL Server sur le port 1433 :

Pour Windows, exécutez :

bash

$Test-NetConnection -ComputerName <YOUR_IP_ADDRESS> -Port <YOUR_PORT_NUMBER>

Pour Linux, exécutez :

bash

$nc -zv <YOUR_IP_ADDRESS> <YOUR_PORT_NUMBER>

Métriques disponibles

Monitorez les performances de votre base de données SQL Server 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 SQL Server de New Relic et sont collectées automatiquement, quelle que soit votre configuration.

Nom métrique	Description
`sqlserver.stats.connections`	Connexions utilisateur actuelles
`sqlserver.instance.blocked_processes_count`	Nombre de processus bloqués
`sqlserver.instance.buffer_pool_hit_percent`	Pourcentage de réussite du pool de tampons
`sqlserver.instance.buffer_pool_size`	Taille du pool de tampons
`sqlserver.instance.compilations_per_batch`	Compilations SQL par demande de lot
`sqlserver.instance.connections_active`	Nombre de connexions actives
`sqlserver.instance.forced_parameterizations_per_sec`	Paramétrisations forcées par seconde
`sqlserver.instance.full_scans_rate`	Balayages complets de table/index par seconde
`sqlserver.instance.lock_timeouts_rate`	Nombre de dépassements de délai de verrouillage par seconde
`sqlserver.instance.memory_available`	Mémoire physique disponible sur le système
`sqlserver.instance.memory_utilization_percent`	Pourcentage d'utilisation de la mémoire
`sqlserver.instance.page_splits_per_batch`	Divisions de page par requête de lot
`sqlserver.instance.target_memory_kb`	Mémoire du serveur cible en Ko
`sqlserver.instance.transactions_per_sec`	Transactions par seconde
`sqlserver.buffer.cache_hit_ratio`	Pourcentage du taux de réussite du cache des tampons
`sqlserver.buffer.checkpoint_pages_per_sec`	Pages de point de contrôle par seconde
`sqlserver.buffer.page_life_expectancy`	Espérance de vie de la page en secondes
`sqlserver.bufferpool.page_life_expectancy_ms`	Espérance de vie des pages en millisecondes
`sqlserver.database.io.stall_ms`	Temps total de blocage d'E/S pour la base de données SQL Server
`sqlserver.database.log.flushes_per_sec`	Nombre d'opérations de vidage de log par seconde
`sqlserver.database.log.transaction_growth`	Nombre d'événements de croissance du log pour la base de données SQL Server
`sqlserver.database.page_file_available_bytes`	Espace de fichier de pagination disponible pour la base de données SQL Server
`sqlserver.database.page_file_total_bytes`	Espace total du fichier de pagination pour la base de données SQL Server
`sqlserver.database.size.data_mb`	Taille totale des fichiers de données hors fichiers de log
`sqlserver.database.size.total_mb`	Taille totale de la base de données incluant les fichiers de données et les fichiers de log
`sqlserver.stats.deadlocks_per_sec`	Interblocages par seconde
`sqlserver.stats.kill_connection_errors_per_sec`	Erreurs d'interruption de connexion par seconde
`sqlserver.stats.lock_waits_per_sec`	Attentes de verrou par seconde
`sqlserver.stats.sql_compilations_per_sec`	Compilations SQL par seconde
`sqlserver.stats.sql_recompilations_per_sec`	Recompilations SQL par seconde
`sqlserver.stats.user_errors_per_sec`	Erreurs utilisateur par seconde
`sqlserver.wait_stats.wait_time_ms`	Temps d'attente total en millisecondes
`sqlserver.access.page_splits_per_sec`	Divisions de page par seconde
`sqlserver.execution.plan`	Opérateur de plan d'exécution SQL Server avec estimations de coût détaillées
`sqlserver.plan.avg_elapsed_time_ms`	Temps écoulé moyen par exécution de ce plan (historique)
`sqlserver.slowquery.avg_elapsed_time_ms`	Temps écoulé moyen par exécution en millisecondes
`sqlserver.slowquery.historical_avg_elapsed_time_ms`	Moyenne historique du temps écoulé en millisecondes
`sqlserver.slowquery.historical_execution_count`	Nombre d'exécutions historiques
`sqlserver.slowquery.historical_logical_reads`	Total historique des lectures logiques
`sqlserver.slowquery.historical_physical_reads`	Total historique des lectures physiques
`sqlserver.slowquery.historical_rows`	Historique du nombre total de lignes renvoyées
`sqlserver.slowquery.historical_wait_time_ms`	Temps d'attente total historique en millisecondes
`sqlserver.slowquery.historical_worker_time_ms`	Temps de travail (CPU) total historique en millisecondes
`sqlserver.slowquery.interval_avg_elapsed_time_ms`	Temps écoulé moyen de l'intervalle en millisecondes
`sqlserver.slowquery.interval_avg_logical_reads`	Moyenne des lectures logiques par exécution sur l'intervalle
`sqlserver.slowquery.interval_avg_physical_reads`	Moyenne des lectures physiques par exécution sur l'intervalle
`sqlserver.slowquery.interval_avg_rows`	Moyenne des lignes renvoyées par exécution sur l'intervalle
`sqlserver.slowquery.interval_avg_wait_time_ms`	Temps d'attente moyen de l'intervalle par exécution en millisecondes
`sqlserver.slowquery.interval_avg_worker_time_ms`	Temps de travail (CPU) moyen par exécution sur l'intervalle en millisecondes
`sqlserver.slowquery.interval_elapsed_time_ms`	Temps total écoulé de l'intervalle en millisecondes
`sqlserver.slowquery.interval_execution_count`	Nombre d'exécutions par intervalle
`sqlserver.slowquery.interval_logical_reads`	Lectures logiques d'intervalle
`sqlserver.slowquery.interval_physical_reads`	Lectures physiques d'intervalle
`sqlserver.slowquery.interval_rows`	Lignes d'intervalle renvoyées
`sqlserver.slowquery.interval_wait_time_ms`	Temps d'attente de l'intervalle en millisecondes
`sqlserver.slowquery.interval_worker_time_ms`	Temps (CPU) du worker de l'intervalle en millisecondes
`sqlserver.slowquery.query_details`	Détails des requêtes, y compris le texte et les horodatages pour les requêtes lentes
`sqlserver.activequery.wait_time_seconds`	Temps d'attente pour la requête en cours d'exécution
`sqlserver.blocking_query.details`	Détails de la requête bloquante pour la corrélation avec les requêtes actives

Métriques supplémentaires

Activez ces métriques supplémentaires au besoin pour obtenir des informations plus approfondies sur les performances et l'état de santé de votre base de données SQL Server.

Activez enable_instance_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.instance.background_processes_count`	Nombre de processus en arrière-plan
`sqlserver.instance.disk_in_bytes`	Espace disque total en octets
`sqlserver.instance.dormant_processes_count`	Nombre de processus dormants
`sqlserver.instance.memory_total`	Mémoire physique totale du système
`sqlserver.instance.preconnect_processes_count`	Nombre de processus de préconnexion
`sqlserver.instance.runnable_processes_count`	Nombre de processus exécutables
`sqlserver.instance.runnable_tasks`	Nombre de tâches exécutables
`sqlserver.instance.running_processes_count`	Nombre de processus en cours d'exécution
`sqlserver.instance.sleeping_processes_count`	Nombre de processus en veille
`sqlserver.instance.suspended_processes_count`	Nombre de processus suspendus

Nom métrique	Description
`sqlserver.bufferpool.batch_requests_per_sec`	Requêtes de lot par seconde

Nom métrique	Description
`sqlserver.connections.user`	Nombre de connexions utilisateur

Activez enable_database_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.database.bufferpool.size_per_database_bytes`	Taille du pool de mémoires tampons SQL Server alloué pour la base de données
`sqlserver.database.log.bytes_flushed_per_sec`	Nombre d'octets de logs vidés par seconde
`sqlserver.database.log.flush_waits_per_sec`	Nombre d'opérations d'attente de vidage par seconde
`sqlserver.database.log.used_space_mb`	Espace de logs utilisé en mégaoctets
`sqlserver.database.max_disk_size_bytes`	Taille de disque maximale autorisée pour la base de données SQL Server
`sqlserver.database.principals.applicationRoles`	Nombre de rôles d'application
`sqlserver.database.principals.old`	Nombre d'anciens principaux (plus de 365 jours)
`sqlserver.database.principals.orphanedUsers`	Nombre d'utilisateurs orphelins sans connexion au serveur
`sqlserver.database.principals.recentlyCreated`	Nombre de principaux récemment créés (30 derniers jours)
`sqlserver.database.principals.roles`	Nombre de rôles de base de données
`sqlserver.database.principals.sqlUsers`	Nombre d'utilisateurs de l'authentification SQL
`sqlserver.database.principals.total`	Nombre total de principaux de base de données
`sqlserver.database.principals.users`	Nombre d'utilisateurs de la base de données
`sqlserver.database.principals.windowsUsers`	Nombre d'utilisateurs de l'authentification Windows
`sqlserver.database.role.members.applicationRoles`	Nombre de membres du rôle d'application
`sqlserver.database.role.members.crossRole`	Nombre de membres inter-rôles
`sqlserver.database.role.members.highPrivilege`	Nombre de membres de rôles à privilèges élevés
`sqlserver.database.role.members.unique`	Nombre de membres uniques dans les rôles
`sqlserver.database.role.memberships.active`	Nombre d'appartenances actives aux rôles
`sqlserver.database.role.memberships.custom`	Nombre d'appartenances à des rôles personnalisés
`sqlserver.database.role.memberships.nested`	Nombre d'appartenances à des rôles imbriqués
`sqlserver.database.role.memberships.total`	Nombre total d'appartenances aux rôles
`sqlserver.database.role.memberships.users`	Nombre d'appartenances aux rôles utilisateur
`sqlserver.database.role.permission.memberCount`	Nombre de membres dans le rôle
`sqlserver.database.role.permission.riskLevel`	Niveau de risque du rôle
`sqlserver.database.role.roles.empty`	Nombre de rôles vides
`sqlserver.database.role.roles.withMembers`	Nombre de rôles uniques avec des membres
`sqlserver.database.transactions.active`	Nombre de transactions actives

Activez enable_failover_cluster_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.failover_cluster.ag_cluster_type`	Type de cluster pour le groupe de disponibilité
`sqlserver.failover_cluster.ag_failure_condition_level`	Niveau de condition de basculement automatique pour le groupe de disponibilité
`sqlserver.failover_cluster.ag_health_check_timeout`	Délai d'attente du contrôle d'intégrité pour le groupe de disponibilité en millisecondes
`sqlserver.failover_cluster.ag_replica_role`	Rôle actuel du réplica au sein du groupe de disponibilité
`sqlserver.failover_cluster.ag_required_sync_secondaries`	Nombre de réplicas secondaires synchrones requis pour valider les transactions
`sqlserver.failover_cluster.ag_synchronization_health`	Santé de la synchronisation des données entre le réplica primaire et le réplica secondaire
`sqlserver.failover_cluster.flow_control_time_ms`	Temps passé dans le contrôle de flux par les enregistrements de logs provenant du réplica principal en millisecondes par seconde
`sqlserver.failover_cluster.log_bytes_received_per_sec`	Taux d'enregistrements de logs reçus par le réplica secondaire depuis le réplica primaire en octets par seconde
`sqlserver.failover_cluster.log_send_queue_kb`	Quantité d'enregistrements de log dans la file d'attente d'envoi du log en attente d'être envoyés au réplica secondaire, en kilo-octets
`sqlserver.failover_cluster.redo_queue_kb`	Quantité d'enregistrements de logs dans la file d'attente de restauration en attente d'être refaits sur le réplica secondaire en kilo-octets
`sqlserver.failover_cluster.redo_rate_kb_sec`	Taux auquel les enregistrements de logs sont refaits sur le réplica secondaire en kilo-octets par seconde
`sqlserver.failover_cluster.transaction_delay_ms`	Délai moyen des transactions sur le réplica secondaire en millisecondes

Activez enable_lock_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.lock.mode.bulk_update`	Nombre de verrous de mise à jour en masse
`sqlserver.lock.mode.exclusive`	Nombre de verrous exclusifs
`sqlserver.lock.mode.intent`	Nombre de verrous d'intention
`sqlserver.lock.mode.schema`	Nombre de verrous de schéma
`sqlserver.lock.mode.shared`	Nombre de verrous partagés
`sqlserver.lock.mode.shared_intent_exclusive`	Nombre de verrous partagés avec intention exclusive
`sqlserver.lock.mode.total`	Total des verrous actifs par mode
`sqlserver.lock.mode.update`	Nombre de verrous de mise à jour
`sqlserver.lock.resource.allocation_unit`	Nombre de verrous d'unité d'allocation
`sqlserver.lock.resource.application`	Nombre de verrous d'application
`sqlserver.lock.resource.database_level`	Nombre de verrous au niveau de la base de données
`sqlserver.lock.resource.extent`	Nombre de verrous au niveau de l'extension
`sqlserver.lock.resource.file`	Nombre de verrous au niveau fichier
`sqlserver.lock.resource.hobt`	Nombre de verrous de tas ou de B-tree
`sqlserver.lock.resource.key`	Nombre de verrous au niveau de la clé
`sqlserver.lock.resource.metadata`	Nombre de verrous de métadonnées
`sqlserver.lock.resource.page`	Nombre de verrous au niveau de la page
`sqlserver.lock.resource.row`	Nombre de verrous de ligne
`sqlserver.lock.resource.table`	Nombre de verrous au niveau de la table
`sqlserver.lock.resource.total`	Total des verrous actifs dans la base de données

Nom métrique	Description
`sqlserver.locked_object`	Objet de base de données verrouillé par une session

Activez enable_instance_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.memory.target`	Mémoire du serveur cible en Ko
`sqlserver.memory.total`	Mémoire totale du serveur en Ko

Activez enable_security_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.security.server_principals_count`	Nombre total de principaux de serveur (connexions)
`sqlserver.security.server_role_members_count`	Nombre total de membres du rôle de serveur

Activez enable_tempdb_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.tempdb.allocation_waits_ms`	Temps d'attente total lié à l'allocation
`sqlserver.tempdb.current_waiters`	Nombre de tâches actuellement en attente de verrous de page TempDB
`sqlserver.tempdb.data_file_count`	Nombre de fichiers de données TempDB
`sqlserver.tempdb.pagelatch_waits_ms`	Temps d'attente total des latchs de page depuis le démarrage du serveur
`sqlserver.tempdb.total_size_mb`	Taille totale des fichiers de données TempDB

Activez enable_thread_pool_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.threadpool.current_tasks`	Total des tâches actuellement assignées aux planificateurs
`sqlserver.threadpool.max_workers`	Nombre maximal de threads de travail configurés
`sqlserver.threadpool.runnable_tasks`	Tâches prêtes à s'exécuter mais en attente de temps CPU
`sqlserver.threadpool.running_workers`	Nombre de threads de travail en cours d'exécution
`sqlserver.threadpool.utilization_percent`	Pourcentage de threads de travail actuellement utilisés
`sqlserver.threadpool.waiting_tasks`	Nombre de tâches actuellement en attente de threads de travail du pool de threads
`sqlserver.threadpool.work_queue_count`	Nombre total de tâches dans les files d'attente de travail du planificateur

Activez enable_user_connection_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.user_connections.authentication.churn_rate`	Taux de rotation des connexions (ratio déconnexion/connexion en pourcentage)
`sqlserver.user_connections.authentication.logins_per_sec`	Taux de connexion actuel par seconde
`sqlserver.user_connections.authentication.recent_failed_logins`	Nombre d'échecs de connexion au cours de la dernière heure
`sqlserver.user_connections.authentication.total_failed_logins`	Nombre total de tentatives de connexion échouées dans le log d'erreurs actuel
`sqlserver.user_connections.authentication.unique_failed_sources`	Nombre d'adresses IP source distinctes avec des échecs de connexion
`sqlserver.user_connections.authentication.unique_failed_users`	Nombre de noms d'utilisateur distincts avec des échecs de connexion
`sqlserver.user_connections.client.count`	Nombre de connexions groupées par hôte client et programme
`sqlserver.user_connections.client.unique_hosts`	Nombre d'hôtes clients uniques avec des connexions actives
`sqlserver.user_connections.client.unique_programs`	Nombre de programmes uniques avec des connexions actives
`sqlserver.user_connections.runnable`	Nombre de connexions utilisateur exécutables
`sqlserver.user_connections.running`	Nombre de connexions utilisateur en cours
`sqlserver.user_connections.sleeping`	Nombre de connexions utilisateur en sommeil
`sqlserver.user_connections.suspended`	Nombre de connexions utilisateur suspendues
`sqlserver.user_connections.total`	Nombre total de connexions utilisateur pour tous les statuts
`sqlserver.user_connections.utilization.active_ratio`	Ratio des connexions actives par rapport au total des connexions
`sqlserver.user_connections.utilization.idle_ratio`	Ratio des connexions inactives par rapport aux connexions totales

Activez enable_wait_time_metrics: true pour collecter ces métriques :

Nom métrique	Description
`sqlserver.wait_stats.latch.wait_time_ms`	Temps d'attente de latch en millisecondes
`sqlserver.wait_stats.latch.waiting_tasks_count`	Nombre de tâches en attente de latchs
`sqlserver.wait_stats.waiting_tasks_count`	Nombre de tâches actuellement en attente

Et ensuite ?

Après avoir configuré le monitoring de la base de données SQL Server 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é.

Supervision de Microsoft SQL Server avec NRDOT

Aperçu

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

Configurer le collecteur NRDOT pour le monitoring de Microsoft SQL Server

Configurer le collecteur NRDOT

Important

Pour Linux

Configurer l'utilisateur de la base de données

Pour Windows (SSMS)

Pour Linux (sqlcmd)

Configurer le collecteur NRDOT

Important

Paramètres de configuration

Redémarrer le collecteur NRDOT

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

Gestion des services Windows

Gestion des services Linux

Dépannage

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 d'instance

Métriques du pool de tampons

Métriques de connexions

base de données métriques

Métriques de cluster de basculement

Métriques de verrous

Métriques d'objets verrouillés

mémoires métriques

Métriques de sécurité

Métriques TempDB

Métriques du pool de threads

Métriques des connexions utilisateur

Métriques de statistiques d'attente

Et ensuite ?

Prérequis