Documentation PulseRadar

curl -sSL https://pulseradar.cloud/install | bash -s -- --api-key <VOTRE_CLÉ>

# Installation automatique (recommandée)
curl -sSL https://pulseradar.cloud/install | bash -s -- --api-key <CLÉ>

# Options disponibles
--api-key <CLÉ>        Clé API (obligatoire)
--server-name <NOM>    Nom affiché dans le dashboard (défaut: hostname)

# PowerShell en administrateur
[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
iex (New-Object Net.WebClient).DownloadString('https://pulseradar.cloud/install.ps1')

# Statut
sudo systemctl status pulseradar-agent

# Redémarrage
sudo systemctl restart pulseradar-agent

# Logs de l'agent
sudo journalctl -u pulseradar-agent -f

/etc/pulseradar/agent.conf        Configuration de l'agent
/etc/fluent-bit/fluent-bit.conf Configuration Fluent Bit (auto-généré)
/etc/fluent-bit/parsers.conf    Parseurs de logs

{
  "level":     "error",          // fatal|critical|error|warning|info|debug
  "message":   "Connection refused to database",
  "source":    "mon-app",        // identifiant libre de la source
  "timestamp": "2026-03-30T14:00:00Z",  // optionnel, défaut: maintenant
  "host":      "web01",          // optionnel
  "fields": {                    // données structurées libres
    "user_id": "42",
    "duration_ms": "320"
  }
}

# Log unique
curl -X POST https://ingest.pulseradar.cloud/v1/logs \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '{"level":"error","message":"Oops","source":"mon-app"}'

# Batch (jusqu'à 500 événements par requête)
curl -X POST https://ingest.pulseradar.cloud/v1/logs \
  -H "Authorization: Bearer <API_KEY>" \
  -H "Content-Type: application/json" \
  -d '[{"level":"info","message":"Start"},{"level":"error","message":"Fail"}]'

# Télécharger
curl -O https://pulseradar.cloud/sdk/nodejs/index.js

const PulseRadar = require('./index.js') // ou le chemin vers le fichier

const logger = new PulseRadar({
  apiKey:   process.env.PULSERADAR_API_KEY,
  serverId: process.env.PULSERADAR_SERVER_ID, // optionnel
  source:   'mon-api',
})

// Logs avec fields
logger.info('Serveur démarré', { port: '3000', env: 'production' })
logger.error('Erreur DB', { query: 'SELECT ...', duration_ms: '320' })

// Capture d'exception avec stack trace
try {
  riskyOperation()
} catch (err) {
  logger.captureException(err, { user_id: '42', route: '/api/users' })
}

// Express middleware — capture globale des erreurs
app.use((err, req, res, next) => {
  logger.captureException(err, { path: req.path, method: req.method })
  res.status(500).json({ error: 'Internal error' })
})

// IMPORTANT : flush avant exit (scripts, Lambda)
process.on('beforeExit', () => logger.flush())

# Télécharger
mkdir -p pulseradar
curl -o pulseradar/__init__.py https://pulseradar.cloud/sdk/python/pulseradar/__init__.py

from pulseradar import PulseRadar
import os

logger = PulseRadar(
    api_key=os.environ["PULSERADAR_API_KEY"],
    server_id=os.environ.get("PULSERADAR_SERVER_ID"),
    source="mon-api",
)

# Logs avec fields (kwargs)
logger.info("Démarrage", version="1.0", port="8000")
logger.error("Erreur DB", query="SELECT ...", duration_ms="320")

# Capture d'exception (utilise sys.exc_info si pas d'argument)
try:
    risky()
except Exception:
    logger.capture_exception(user_id="42")

# Django middleware
class PulseRadarMiddleware:
    def process_exception(self, request, exception):
        logger.capture_exception(exception, path=request.path)

# Flask error handler
@app.errorhandler(Exception)
def handle_error(e):
    logger.capture_exception(e)
    return "Error", 500

# IMPORTANT : flush en fin de script
import atexit
atexit.register(logger.flush)

# Télécharger
curl -O https://pulseradar.cloud/sdk/php/src/PulseRadar.php

require_once __DIR__ . '/PulseRadar.php';
use PulseRadar\PulseRadar;

$logger = new PulseRadar([
    'api_key'   => getenv('PULSERADAR_API_KEY'),
    'server_id' => getenv('PULSERADAR_SERVER_ID'),
    'source'    => 'mon-api',
    'async'     => true,  // batch + flush au __destruct
]);

$logger->info('Démarrage');
$logger->error('Erreur DB', ['query' => 'SELECT ...', 'duration_ms' => '320']);

// Capture d'exception
try {
    risky();
} catch (\Throwable $e) {
    $logger->captureException($e, ['user_id' => '42']);
}

// Laravel : dans app/Exceptions/Handler.php
public function report(\Throwable $e) {
    app(PulseRadar::class)->captureException($e);
    parent::report($e);
}

curl -O https://pulseradar.cloud/sdk/ruby/lib/pulseradar.rb

require_relative 'pulseradar'

logger = PulseRadar::Client.new(
  api_key:   ENV['PULSERADAR_API_KEY'],
  server_id: ENV['PULSERADAR_SERVER_ID'],
  source:    'mon-api',
)

logger.info('Démarrage', port: '3000')
logger.error('Erreur DB', query: 'SELECT ...')

# Capture d'exception
begin
  risky_operation
rescue => e
  logger.capture_exception(e, user_id: '42')
end

# Rails : dans config/initializers/pulseradar.rb
Rails.application.config.middleware.use(proc { |env|
  begin
    @app.call(env)
  rescue => e
    PULSERADAR.capture_exception(e, path: env['PATH_INFO'])
    raise
  end
})

# Télécharger
curl -O https://pulseradar.cloud/sdk/java/src/main/java/cloud/pulseradar/PulseRadar.java
curl -O https://pulseradar.cloud/sdk/java/src/main/java/cloud/pulseradar/PulseRadarLogbackAppender.java

// Usage direct
PulseRadar logger = new PulseRadar.Builder()
    .apiKey(System.getenv("PULSERADAR_API_KEY"))
    .serverId(System.getenv("PULSERADAR_SERVER_ID"))
    .source("mon-api")
    .build();

logger.info("Server started", Map.of("port", "8080"));
logger.error("DB failed", Map.of("query", "SELECT ..."));

try { riskyOperation(); }
catch (Exception e) { logger.captureException(e, Map.of("user_id", "42")); }

// IMPORTANT : flush au shutdown
Runtime.getRuntime().addShutdownHook(new Thread(logger::flush));

<!-- src/main/resources/logback.xml -->
<appender name="PULSERADAR" class="cloud.pulseradar.PulseRadarLogbackAppender">
  <apiKey>${PULSERADAR_API_KEY}</apiKey>
  <source>mon-api</source>
  <serverId>${PULSERADAR_SERVER_ID}</serverId>
</appender>
<root level="WARN">
  <appender-ref ref="PULSERADAR" />
</root>

# Télécharger
mkdir -p pulseradar && cd pulseradar
curl -O https://pulseradar.cloud/sdk/go/pulseradar.go
curl -O https://pulseradar.cloud/sdk/go/slog.go
curl -O https://pulseradar.cloud/sdk/go/go.mod

package main

import (
    "log/slog"
    "os"
    pulseradar "./pulseradar" // chemin local
)

func main() {
    client := pulseradar.New(os.Getenv("PULSERADAR_API_KEY"),
        pulseradar.WithSource("mon-api"),
        pulseradar.WithServerID(os.Getenv("PULSERADAR_SERVER_ID")),
    )
    defer client.Close() // flush les logs restants

    client.Info("Démarrage", pulseradar.F("port", "8080"))
    client.Error("Erreur DB", pulseradar.F("query", "SELECT ..."))

    if err := riskyOperation(); err != nil {
        client.CaptureException(err, pulseradar.F("user_id", "42"))
    }

    // Intégration log/slog (Go 1.21+)
    logger := slog.New(pulseradar.NewSlogHandler(client))
    slog.SetDefault(logger)
    slog.Info("Hello from slog", "key", "value")
}

// Gin middleware
func PulseRadarMiddleware(client *pulseradar.Client) gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Next()
        for _, err := range c.Errors {
            client.CaptureException(err.Err, pulseradar.F("path", c.FullPath()))
        }
    }
}

curl -O https://pulseradar.cloud/sdk/dotnet/PulseRadar/PulseRadar.cs

using PulseRadar;

var logger = new PulseRadarClient(
    apiKey: Environment.GetEnvironmentVariable("PULSERADAR_API_KEY")!,
    source: "mon-api",
    serverId: Environment.GetEnvironmentVariable("PULSERADAR_SERVER_ID")
);

logger.Info("Démarrage", new() { ["port"] = "5000" });
logger.Error("Erreur DB", new() { ["query"] = "SELECT ..." });

try { RiskyOperation(); }
catch (Exception ex) { logger.CaptureException(ex, new() { ["user_id"] = "42" }); }

// ASP.NET Core : dans Program.cs
app.Use(async (context, next) => {
    try { await next(); }
    catch (Exception ex) {
        logger.CaptureException(ex, new() { ["path"] = context.Request.Path });
        throw;
    }
});

// IMPORTANT : dispose en fin de vie
using var logger = new PulseRadarClient(...);

mkdir -p pulseradar/src && cd pulseradar
curl -O https://pulseradar.cloud/sdk/rust/Cargo.toml
curl -o src/lib.rs https://pulseradar.cloud/sdk/rust/src/lib.rs

use pulseradar::{Client, Field};

let client = Client::new("pr_your_api_key")
    .source("mon-api")
    .server_id("optional-server-id");

client.info("Démarrage", &[Field::new("port", "8080")]);
client.error("Erreur DB", &[Field::new("query", "SELECT ...")]);

// Capture d'erreur
client.capture_error(&some_error, &[Field::new("user_id", "42")]);

// Le client flush automatiquement au drop
drop(client);

[INPUT]
    Name   tail
    Path   /var/log/mon-app/*.log
    Tag    mon-app

[FILTER]
    Name   record_modifier
    Match  mon-app
    Record source mon-app
    Record server_id ${SERVER_ID}
    Record project_id ${PROJECT_ID}

[OUTPUT]
    Name        http
    Match       mon-app
    Host        ingest.pulseradar.cloud
    Port        443
    URI         /v1/logs/fluent-bit
    Format      json
    Header      Authorization Bearer ${API_KEY}

log_format pulseradar '$remote_addr - $remote_user [$time_local] '
                    '"$request" $status $body_bytes_sent '
                    '"$http_referer" "$http_user_agent" '
                    'rt=$request_time';

access_log /var/log/nginx/access.log pulseradar;

# /etc/mysql/mysql.conf.d/mysqld.cnf
slow_query_log        = 1
slow_query_log_file   = /var/log/mysql/slow.log
long_query_time       = 0.5      # requêtes > 500ms
log_queries_not_using_indexes = 1

# /etc/postgresql/*/main/postgresql.conf
log_min_duration_statement = 500   # ms — requêtes > 500ms
log_line_prefix = '%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '

slowlog = /var/log/php-fpm-slow.log
request_slowlog_timeout = 2s

Avant :  SELECT * FROM users WHERE id = 42 AND status = 'active'
Après :  SELECT * FROM users WHERE id = ? AND status = ?

Avant :  SELECT * FROM orders WHERE id IN (1, 2, 3, 4, 5)
Après :  SELECT * FROM orders WHERE id IN (?)

POST https://ingest.pulseradar.cloud/v1/traces
Authorization: Bearer <API_KEY>
X-Server-Id: <SERVER_ID>
Content-Type: application/json

export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.pulseradar.cloud
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <API_KEY>,X-Server-Id=<SERVER_ID>"
export OTEL_EXPORTER_OTLP_PROTOCOL=http/json
export OTEL_SERVICE_NAME=mon-app

npm install @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http

const { NodeSDK } = require('@opentelemetry/sdk-node')
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http')

new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    url: 'https://ingest.pulseradar.cloud/v1/traces',
    headers: {
      'Authorization': 'Bearer <API_KEY>',
      'X-Server-Id': '<SERVER_ID>',
    },
  }),
  serviceName: 'mon-app',
}).start()

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http

from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter

provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(
    endpoint="https://ingest.pulseradar.cloud/v1/traces",
    headers={"Authorization": "Bearer <API_KEY>", "X-Server-Id": "<SERVER_ID>"}
)))

composer require open-telemetry/sdk open-telemetry/exporter-otlp

# .env
OTEL_PHP_AUTOLOAD_ENABLED=true
OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.pulseradar.cloud
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <API_KEY>,X-Server-Id=<SERVER_ID>"

PROXMOX_HOST=https://pve.example.com:8006
PROXMOX_TOKEN_ID=root@pam!monitoring
PROXMOX_TOKEN=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

VMWARE_HOST=https://vcenter.example.com
VMWARE_USER=monitoring@vsphere.local
VMWARE_PASSWORD=your_password

XCPNG_HOST=https://xcp.example.com
XCPNG_USER=root
XCPNG_PASSWORD=your_password

NUTANIX_HOST=https://prism.example.com:9440
NUTANIX_USER=admin
NUTANIX_PASSWORD=your_password

Authorization: Bearer <API_KEY>

GET /v1/logs?project_id=<ID>&level=error&limit=100
Authorization: Bearer <API_KEY>