Skip to content
Learni
Voir tous les tutoriels
Observabilité

Comment monitorer une app Node.js avec New Relic en 2026

14 minINTERMEDIATE
MonitoringNode.jsAPMObservabilitéNew Relic
Read in English

Introduction

New Relic est la plateforme d'observabilité leader en 2026, offrant un monitoring APM (Application Performance Monitoring), infrastructure et logs en une interface unifiée. Pour une app Node.js, cela signifie tracer les requêtes lentes, détecter les fuites mémoire et alerter sur les pics de CPU en temps réel. Ce tutoriel intermédiaire vous guide pas à pas : de l'installation de l'agent à la création de dashboards custom. Pourquoi c'est crucial ? En production, 70% des incidents viennent de performances dégradées (source : New Relic State of Observability 2025). Avec ces étapes, vous déployez un monitoring full-stack en moins d'une heure, scalable pour microservices. Analogie : comme un tableau de bord avion pour votre code, New Relic affiche latence, throughput et erreurs sans effort devops excessif. Prêt à transformer vos logs en insights actionnables ? (142 mots)

Prérequis

  • Compte New Relic gratuit (créez-en un sur one.newrelic.com) avec license key récupérée dans Account Settings > API Keys.
  • Node.js 18+ installé.
  • Une app Node.js basique (Express recommandée).
  • Accès shell pour installation packages.
  • Connaissances TypeScript/JS intermédiaires.

Installation de l'agent New Relic pour Node.js

terminal-install.sh
mkdir my-node-app && cd my-node-app
npm init -y
npm install express newrelic
npm install --save-dev nodemon

Ce script initialise un projet Node.js vide, installe Express pour l'API et l'agent New Relic officiel. Nodemon est ajouté pour le hot-reload en dev. Attention : utilisez toujours --save-dev pour les outils dev afin d'éviter les bundles en prod ; exécutez dans un dossier vide pour éviter conflits package.json.

Premier lancement et obtention de la license key

Connectez-vous à one.newrelic.com, naviguez vers APM & Services > New apps pour voir votre app apparaître après instrumentation. Copiez votre license key (format : NRxx-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX) depuis Account > API keys > License key. Collez-la dans la config suivante. Astuce : activez Instant Observability pour un onboarding UI guidé, qui scanne auto vos endpoints et crée des dashboards basiques en 2 clics.

Configuration complète de l'agent (newrelic.js)

newrelic.js
    'license_key': 'VOTRE_LICENSE_KEY_ICI',
    'logging': {
      'level': 'info'
    },
    'max_event_samples_stored': 10000,
    'slow_sql': {
      'enabled': true
    },
    'errors_wrapper': ['__express_error_handler'],
    'attributes': {
      'exclude': [
        'request.headers.cookie',
        'request.headers.authorization',
        'request.headers.proxyAuthorization',
        'request.headers.setcookie*',
        'request.headers.x*',
        'response.headers.cookie',
        'response.headers.authorization',
        'response.headers.setcookie*'
      ]
    }
  };

  // Injecte distributed tracing
  if (process.env.NEW_RELIC_DISTRIBUTED_TRACING_ENABLED === 'true') {
    newrelicConfig.distributed_tracing = {
      enabled: true
    };
  }

Ce fichier de config active l'agent avec logging info, slow SQL detection et exclusion d'attributs sensibles (PII compliance GDPR). Distributed tracing est optionnel via ENV. Piège : remplacez VOTRE_LICENSE_KEY_ICI par votre vraie clé, sinon l'agent silent-fail ; placez ce fichier à la racine du projet pour auto-chargement.

Instrumentation automatique de l'app

L'agent New Relic s'instrumente via require('newrelic') en premier ligne, capturant auto Express routes, DB queries et HTTP clients. Testez avec npm run dev : dans New Relic UI, votre app apparaît sous APM > Services avec métriques de base (response time, throughput). Filtrez par Golden signals pour prioriser latence/erreurs.

Application Express instrumentée

app.js
require('newrelic');

const express = require('express');
const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());

app.get('/', (req, res) => {
  res.json({ message: 'Hello monitored by New Relic!' });
});

app.get('/slow', async (req, res) => {
  // Simule slow query
  await new Promise(resolve => setTimeout(resolve, 2000));
  res.json({ message: 'Slow endpoint for testing' });
});

app.listen(port, () => {
  console.log(`App listening on port ${port}`);
});

Cette app Express de base est auto-tracée : New Relic capture les endpoints '/', '/slow' avec timings. Le délai artificiel teste slow SQL detection. Astuce : ajoutez NEW_RELIC_APP_NAME=MonAppNode en ENV pour nommer précisément ; évitez async/await non-handlé qui crash silencieusement en prod.

Lancement et première vérification dans l'UI

  • Lancez : node app.js ou nodemon app.js.
  • Ouvrez one.newrelic.com > APM > Services > votre app.
  • Vérifiez Overview : Apdex score >0.9, error rate <1%. Cliquez Transactions pour traces détaillées. Analogie : comme un profiler live, tracez stack par requête.

Ajout de métriques custom et erreurs

app-custom-metrics.js
require('newrelic');

const express = require('express');
const app = express();

app.use(express.json());

app.post('/user/:id', (req, res) => {
  const userId = req.params.id;
  newrelic.getContextManager().setCustomAttribute('user.id', userId);
  newrelic.recordCustomEvent('UserLogin', {
    userId: userId,
    success: true
  });

  if (Math.random() < 0.1) {
    throw new Error('Simulated user error');
  }

  res.json({ success: true });
});

app.use((err, req, res, next) => {
  newrelic.noticeError(err);
  res.status(500).json({ error: err.message });
});

app.listen(3000, () => console.log('Custom metrics app on 3000'));

Ajoute attributs custom (user.id), événements et noticeError pour erreurs. Cela enrichit traces en UI sous Events > Custom. Piège : appelez noticeError seulement dans middleware global ; sans, erreurs sont perdues. Utilisez pour business metrics comme 'UserLogin'.

Configuration agent infrastructure (YAML)

newrelic-infra.yml
name: my-node-host
license_key: VOTRE_LICENSE_KEY_ICI
interval: 10s
proxy_url: http://proxy.company.com:8080
log_file: /var/log/newrelic-infra.log
log_level: info

integrations:
  - name: nri-mongodb
    config:
      databases:
        - mongodb1
        - mongodb2
  - name: nri-kubernetes
    config: { }

metrics_format: p99

Ce config YAML monitore l'hôte (CPU, mem) + intégrations MongoDB/K8s. Interval 10s pour granularité haute. Placez en /etc/newrelic-infra.yml et lancez agent infra. Évitez log_level debug en prod (overhead) ; metrics_format: p99 focus sur 99th percentile pour outliers.

Bonnes pratiques

  • Séparez ENV par env : NEW_RELIC_APP_NAME=prod-app et NEW_RELIC_LOG_LEVEL=warn en prod pour réduire overhead <2%.
  • Utilisez NRQL queries : Dans UI, query SELECT average(duration) FROM Transaction WHERE appName = 'MonAppNode' SINCE 1 hour ago pour alertes custom.
  • Activez Real User Monitoring (RUM) : Ajoutez JS snippet frontend pour corréler front/back traces.
  • Dashboards NerdGraph API : Automatisez via GraphQL pour CI/CD.
  • Scale avec New Relic One : Liez à OpenTelemetry pour hybrid tracing.

Erreurs courantes à éviter

  • License key manquante : App invisible en UI ; vérifiez logs newrelic_agent.log pour 'License key invalid'.
  • require('newrelic') pas premier : Instrumentation incomplète, routes non-tracées.
  • ENV distributed_tracing sans headers : Paix traces cross-service ; ajoutez NEW_RELIC_DISTRIBUTED_TRACING_ENABLED=true.
  • Ignore slow_sql : DB bottlenecks masqués ; activez toujours avec slow_sql.enabled: true.

Pour aller plus loin