Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
rootly-graphify-importer — Trasforma gli incidenti, gli avvisi e i team di Rootly in un grafo di conoscenza interrogabile. Visualizza le dipendenze dei servizi, le lacune nella copertura di turno e i pattern tra incidenti. | Kitploit
Strumenti/GitHubGitHub/rootly-ai-labs/rootly-graphify-importer
Raccolta InformazioniThreat IntelligenceRisposta agli IncidentiAnalisi dei Log
GitHubrootly-ai-labs/rootly-graphify-importer

rootly-graphify-importer

Trasforma gli incidenti, gli avvisi e i team di Rootly in un grafo di conoscenza interrogabile. Visualizza le dipendenze dei servizi, le lacune nella copertura di turno e i pattern tra incidenti.

Vedi Repository
Sito web
42754 mesi faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Rootly Graphify Importer

rootly-graphify

Basato su graphify, uno strumento ispirato all'idea di Andrej Karpathy per un LLM Wiki: invece di riscoprire la conoscenza da zero a ogni query, un LLM costruisce un grafo di conoscenza persistente e strutturato che si arricchisce nel tempo. Graphify prende qualsiasi cartella di file e la trasforma in un grafo interrogabile con comunità, connessioni e punteggi di confidenza. Questo fork lo indirizza verso l'API di Rootly.

Collega l'API di Rootly, raccogli incidenti, alert, team e il catalogo servizi per una finestra temporale selezionata, esportali in un corpus locale e trasforma quel corpus in un grafo di conoscenza interrogabile. Usa graphify rootly per la raccolta e /graphify in Claude Code o Codex quando vuoi un'analisi semantica più approfondita.

Interfaccia di Graphify che mostra dati di incidenti e alert di Rootly come grafo di conoscenza


Installazione

Nuova installazione (Graphify + Rootly importer):

root@kitploit:~
pip install "graphifyy[rootly]"
graphify install            # Claude Code
graphify install --platform codex  # Codex

Aggiungi Rootly importer a una configurazione Graphify esistente:

root@kitploit:~
pip install "graphifyy[rootly]" --upgrade

Imposta la tua chiave API Rootly

Crea un file .env nella root del progetto:

root@kitploit:~
ROOTLY_API_KEY=rootly_...

Esegui il flusso di lavoro

Passo 1: Recupera e costruisci (terminale)

Recupera incidenti, alert attivati e team. Costruisce il grafo iniziale con colori di gravità, filtri per gli alert e livelli per team/servizi.

root@kitploit:~
graphify rootly

Non interattivo:

root@kitploit:~
graphify rootly --api-key-env ROOTLY_API_KEY --days 30 --mode standard

L'output viene scritto in graphify-rootly-data/graphify-out/:

  • graph.html — apri nel browser per esplorare il grafo
  • GRAPH_REPORT.md — nodi principali, comunità, domande suggerite
  • graph.json — grafo grezzo per interrogazioni

Passo 2: Aggiungi significato semantico (agente)

Esegue sottoagenti paralleli sul corpus di incidenti per dedurre temi trasversali, pattern ricorrenti e relazioni di causa-effetto.

Claude Code — scrivi nella chat:

root@kitploit:~
/graphify graphify-rootly-data --mode deep

Codex — scrivi nella chat:

root@kitploit:~
run graphify on graphify-rootly-data --mode deep

Cosa puoi esplorare

PatternCosa mostraPerché un grafo è utile
Mappa di calore degli incidenti per servizioQuali servizi sono in fiamme e quanto grave. La dimensione del nodo = numero di incidenti, il colore = la peggiore gravità.Aggrega servizi che tendono a guastarsi insieme, rivelando dipendenze infrastrutturali nascoste.
Mappa delle reperibilità e delle escalation per teamChi copre cosa in tutti i turni e le politiche di escalation in un'unica visuale.Individua singoli punti di errore — la persona su 4 turni in 3 team — e lacune nella copertura.
Imbuto alert → incidenteQuali sorgenti di alert generano incidenti reali vs. puro rumore.Una sorgente con 200 alert e 0 incidenti è immediatamente visibile dalla dimensione del nodo.
Incidente → azione successivaStiamo davvero risolvendo ciò che si rompe? Bordi solidi = completato, tratteggiati = aperto.Cluster di azioni aperte attorno a un team o servizio evidenziano problemi sistematici di follow-through.
Correlazione di guasti tra serviziQuali servizi si guastano insieme nella stessa finestra temporale.Il rilevamento di comunità trova gruppi con lo stesso destino che probabilmente dipendono dalla stessa infrastruttura sottostante.

Cosa viene raccolto

RisorsaCosaFiltro
IncidentiTitolo, gravità, stato, timeline, servizi, team, descrizioneFinestra di date (--days)
AlertRiepilogo, stato, sorgente, flag di rumore, timelineSolo attivati (collegati a un incidente)
TeamNome, slug, proprietà del servizioTutti i team dell'account

Filtri di visualizzazione

Una volta aperto graph.html in un browser:

  • Team — filtra tutti i nodi per gli incidenti e i servizi di un team specifico
  • Gravità — mostra/nascondi per SEV1–SEV4
  • Incidenti — tutti o solo aperti
  • Alert — attivati (attivo per default) / orfani (spento per default, non raccolti)
  • Intervallo temporale — slider per restringere la finestra degli incidenti

Come funziona

rootly-graphify ha una fase di raccolta da Rootly e una fase di analisi del grafo.

  1. Raccolta deterministica da Rootly. Convalida la chiave API, scegli una finestra di 7, 30 o 90 giorni, recupera gli incidenti il cui started_at cade in quella finestra, recupera i loro alert attivati tramite la sotto-risorsa per incidente, recupera tutti i dati dei team e scrive tutto in una directory del corpus locale.

  2. Costruzione iniziale del grafo Rootly. Il runner integrato di Rootly crea nodi per incidenti, alert, team e servizi, li collega con bordi tipizzati (triggered, affects, owns, responded_by, targets), raggruppa il grafo e scrive graph.html, GRAPH_REPORT.md e graph.json. L'HTML include la codifica a colori per gravità, i livelli team/servizi e i filtri per gli alert.

  3. Arricchimento profondo opzionale. Esegui /graphify ./graphify-rootly-data --mode deep per avviare sottoagenti paralleli sui file markdown e dedurre temi trasversali, razionale e collegamenti concettuali.

  4. Utilizza l'output di primo livello corrente. Dopo l'arricchimento semantico, apri graphify-out/graph.html. L'esportatore generico corrente include già direttamente i filtri e le visualizzazioni mantenuti, quindi non è necessario un passaggio separato di riapplicazione.

Il raggruppamento si basa sulla topologia del grafo — nessun embedding. Leiden trova le comunità tramite la densità dei bordi. I bordi di similarità semantica (semantically_similar_to, contrassegnati INFERRED) influenzano direttamente il rilevamento delle comunità. Nessun passaggio separato di embedding o database vettoriale richiesto.

Ogni relazione è etichettata come EXTRACTED (trovata direttamente nella sorgente), INFERRED (inferenza ragionevole, con un punteggio di confidenza) o AMBIGUOUS (segnalata per revisione).


Cosa ottieni

Nodi principali — incidenti o servizi con il grado più alto (ciò a cui tutto si collega)

Connessioni sorprendenti — collegamenti tra incidenti ordinati per punteggio composito, ciascuno con una spiegazione in linguaggio semplice

Domande suggerite — 4–5 domande a cui il grafo è particolarmente in grado di rispondere sulla tua cronologia degli incidenti

Punteggi di confidenza — ogni bordo INFERRED ha un confidence_score (0.0–1.0). I bordi EXTRACTED sono sempre 1.0.

Bordi di similarità semantica — collegamenti concettuali tra incidenti senza connessione strutturale. Due incidenti causati dallo stesso pattern principale senza condividere servizi o team.

Efficienza dei token — la prima esecuzione estrae e costruisce il grafo (costa token). Ogni query successiva legge il grafo compatto invece del markdown grezzo — è lì che si accumulano i risparmi. La cache SHA256 garantisce che le riesecuzioni processino solo i file modificati.


Utilizzo

root@kitploit:~
# --- Flusso di lavoro Rootly (terminale) ---
graphify rootly                                        # flusso interattivo di importazione Rootly
graphify rootly --days 30                              # raccoglie gli ultimi 30 giorni di incidenti
graphify rootly --api-key-env ROOTLY_API_KEY           # ricerca chiave non interattiva dall'ambiente
graphify rootly --output ./my-rootly-corpus            # scrive il corpus in una cartella personalizzata

# --- Arricchimento semantico (agente: Claude Code / Codex) ---
/graphify ./graphify-rootly-data                       # analizza il corpus Rootly
/graphify ./graphify-rootly-data --mode deep           # bordi INFERRED più aggressivi
/graphify ./graphify-rootly-data --update              # riestrae solo i file modificati

# --- Interroga il grafo (agente) ---
/graphify query "which services have the most recurring incidents?"
/graphify query "what patterns connect the SEV1 incidents?"
/graphify path "payment-api" "auth-service"
/graphify explain "Incident: Database connection pool exhausted"

# --- Esportazioni opzionali ---
/graphify ./graphify-rootly-data --wiki                # wiki navigabile da agente per ogni comunità
/graphify ./graphify-rootly-data --no-viz              # salta HTML, solo report + JSON
/graphify ./graphify-rootly-data --obsidian            # vault Obsidian

# --- Istruzioni per assistente sempre attivo ---
graphify claude install                                # CLAUDE.md + hook PreToolUse (Claude Code)
graphify codex install                                 # AGENTS.md (Codex)

Riesecuzione su nuovi dati

root@kitploit:~
# Recupera dati freschi e ricostruisci
graphify rootly --api-key-env ROOTLY_API_KEY --days 30 --mode standard

# Riarricchisci con passaggio semantico (Claude Code)
/graphify graphify-rootly-data --update
Scarica lo strumento