Scopri come integrare i log di backend di Elastic con i session replay di OpenReplay per ampliare le tue capacità di monitoraggio e debug.

A seconda della tua configurazione, puoi creare una chiave API dalla dashboard di Kibana oppure tramite comandi cURL.

Tramite la dashboard di Kibana

1. Accedi alla tua dashboard di Kibana.

2. Apri Dev Tools: vai su Dev Tools > Console.

3. Crea la chiave API: copia il codice seguente nella console ed eseguilo:

   POST /_security/api_key
   {
     "name": "openreplay-api-key",
     "role_descriptors": {
       "openreplay-role": {
         "cluster": ["all"],
         "index": [
           {
             "names": ["*log*"],
             "privileges": ["read"]
           }
         ]
       }
     }
   }

1. Esegui il comando cURL: lancia il comando seguente nel tuo terminale:

   curl -X POST "https://your-elasticsearch-host:port/_security/api_key" \
   -H 'Content-Type: application/json' \
   -d'
   {
     "name": "openreplay-api-key",
     "role_descriptors": {
       "openreplay-role": {
         "cluster": ["all"],
         "index": [
           {
             "names": ["*log*"],
             "privileges": ["read"]
           }
         ]
       }
     }
   }' \
   -u 'username:password'

   Sostituisci https://your-elasticsearch-host:port con host e porta del tuo Elasticsearch, e username:password con le tue credenziali.

Nota:

• Per impostazione predefinita, questa integrazione cerca i log in tutti gli indici che corrispondono a *log*. Se hai un indice specifico per i log che non rispetta questo schema, modifica il campo names nella richiesta di creazione della chiave API.
• Per specificare più indici, separa i nomi con delle virgole, ad esempio "names": ["index1", "index2"].

Dopo aver eseguito il comando, riceverai una risposta come questa:

{
  "id": "eQWAIG0Bo0VqB8HXFH9-",
  "name": "openreplay-api-key",
  "api_key": "dZ5ycVRJTU-5UW_RYfi1_w"
}

Importante: assicurati di copiare id e api_key, perché ti serviranno per l’integrazione.

Riferimento: Elasticsearch - Create API Key

Nel tuo account OpenReplay, segui questi 3 passaggi per completare la correlazione tra i session replay e i log di backend di Elasticsearch.

1. Vai su Preferences > Integrations in OpenReplay.
2. Seleziona la scheda Backend Logging.
3. Seleziona il progetto per cui vuoi abilitare l’integrazione di Elasticsearch: individua la card dell’integrazione Elasticsearch e fai clic su di essa.

Nella barra laterale dell’integrazione di Elasticsearch, inserisci:

• API KEY ID: l’id della chiave API che hai generato.
• API Key: l’api_key della chiave API che hai generato.
• Indexes: se hai cambiato l’indice durante la generazione della chiave API, specifica qui il nome o i nomi.

• Fai clic su Add per testare la connessione.

Per collegare un evento di Elasticsearch alla sessione utente registrata, un ID di sessione univoco (openReplaySession.id) deve essere propagato dal frontend al backend a ogni richiesta che vuoi tracciare.

Nota: tracker.start() è asincrono e restituisce una Promise. Devi attendere che venga risolta prima di chiamare tracker.getSessionID(), per assicurarti che l’ID di sessione sia disponibile.

// JavaScript Example for for Single Page Applications (SPA):

// Import OpenReplay
import { tracker } from '@openreplay/tracker';

// Initialize the tracker
tracker.configure({
  projectKey: 'YOUR_PROJECT_KEY',
  ingestPoint: "https://openreplay.mydomain.com/ingest", // when dealing with the self-hosted version of OpenReplay
});

// Start the tracker and wait for it to resolve
tracker.start().then(() => {
  // Get the session ID after the tracker has started
  const sessionId = tracker.getSessionID();

  const headers = {
    'Content-Type': 'application/json',
  };

  if (sessionId) {
    headers['openReplaySession.id'] = sessionId;
  }

  // Make the API request
  fetch('https://www.your-backend.com/api/endpoint', {
    method: 'GET', // or 'POST', 'PUT', etc.
    headers,
    // ...other options
  })
    .then(response => {
      // Handle response
    })
    .catch(error => {
      // Handle error
    });
});

Perché OpenReplay possa associare una voce di log di Elasticsearch alla sessione utente registrata, openReplaySession.id deve essere incluso in ogni errore del backend che vuoi tracciare.

import logging
from flask import Flask, request, g

app = Flask(__name__)

# Configure the root logger
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()

# Create a custom logging filter
class OpenReplayFilter(logging.Filter):
    def filter(self, record):
        session_id = getattr(g, 'openreplay_session_id', None)
        if session_id:
            record.msg = f"[openReplaySession.id={session_id}] {record.msg}"
        return True

# Add the filter to the logger
logger.addFilter(OpenReplayFilter())

@app.before_request
def before_request():
    # Extract the session ID from headers and store it in the Flask `g` object
    g.openreplay_session_id = request.headers.get('openReplaySession.id')

@app.route('/api/endpoint')
def api_endpoint():
    # Your logic here

    # Log an event with the session ID automatically included
    logger.info("Endpoint accessed")

    return 'Success', 200

@app.errorhandler(Exception)
def handle_exception(e):
    # Log the error with the session ID automatically included
    logger.error(f"Error: {str(e)}")
    return 'Internal Server Error', 500

if __name__ == '__main__':
    app.run()

Per impostazione predefinita, OpenReplay cerca ogni log associato a una sessione OpenReplay usando gli attributi message e utc_time. Si concentra sui log di errore, identificati verificando se l’attributo tags contiene il valore error.

Nota:

• Struttura dei log personalizzata: se i tuoi log hanno una struttura diversa, potrebbe essere necessario modificare la configurazione di logging o informare il supporto di OpenReplay per adattare la tua configurazione.
• Identificazione degli errori: assicurati che i log di errore siano etichettati correttamente, in modo che OpenReplay possa identificarli.

Se riscontri dei problemi, collegati al nostro Slack e ricevi aiuto dalla nostra community.