Come cercare un testo nei file di log su macOS con uno script Bash personalizzato

Nell’attuale panorama IT, il monitoraggio e la gestione efficiente dei file di log è fondamentale per mantenere l’integrità del sistema e garantire la sicurezza. Che tu sia un professionista IT o un Managed Service Provider (MSP), la possibilità di ricercare e segnalare rapidamente un testo specifico all’interno di un file di log può essere uno strumento potente nel tuo arsenale. In questo articolo presenteremo uno script Bash personalizzato progettato per cercare un testo nei file di log su macOS e avvisare gli utenti.

L’importanza del monitoraggio dei file di log

I file di log sono una componente fondamentale per il funzionamento e la manutenzione dei sistemi IT. Contengono le registrazioni di eventi, processi ed errori che si verificano in un computer o in una rete. Analizzando i file di log, i professionisti IT possono identificare i problemi, rintracciarne la causa principale e garantire la conformità ai requisiti normativi. Tuttavia, controllare manualmente questi file per trovare le informazioni rilevanti può richiedere molto tempo ed è un’attività che può essere soggetta a errori umani.

È qui che entra in gioco l’automazione. L’automazione del processo di monitoraggio dei file di log e l’attivazione di avvisi quando viene rilevato un testo specifico possono far risparmiare tempo e ridurre il rischio di trascurare problemi critici. Lo script di cui parleremo è una soluzione semplice ma efficace per ottenere questo risultato su macOS.

Lo script per cercare un testo nei file di log su macOS:

#!/usr/bin/env bash

# Description: Alert when the specified Text is found in a text file.
#
# Release Notes: Initial Release
#   By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://ninjastage2.wpengine.com/terms-of-use.
#   Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
#   Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
#   Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
#   Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
#   Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
#   Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
#   EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#
# Text to trigger on: [Alert]
#
# Below are all the valid parameters for this script.
# Preset Parameter: --file "/opt/MyLogFile.log" --text batman
#   Alerts when the text "batman" is found in the file /opt/MyLogFile.log
#    This is Case Sensitive
#     Example where it will alert: "I am batman!"
#     Example where it will alert: "Iambatman!"
#     Example where it will not alert: "IamBatman!"
#     Example where it will not alert: "I am Batman!"
#
# Preset Parameter: --file "/opt/MyLogFile.log" --text Batman --caseInsensitive true
#   Alerts when the text "Batman" is found in the file /opt/MyLogFile.log, but is case insensitive
#    This is Case Insensitive
#     Example where it will alert: "I am batman!"
#     Example where it will alert: "Iambatman!"
#
# Preset Parameter: --file "/opt/MyLogFile.log" --text Batman --wholeWord true
#   Alerts when the text "Batman" is found in the file /opt/MyLogFile.log, but only if it is a word in a sentence.
#    This is Case Sensitive
#     Example where it will alert: "I am Batman!"
#     Example where it will not alert: "IamBatman!"
#

# Determines whether or not help text is necessary and routes the output to stderr
die() {
    local _ret="${2:-1}"
    test "${_PRINT_HELP:-no}" = yes && print_help >&2
    echo "$1" >&2
    exit "${_ret}"
}

# Function that evaluates whether a value passed to it begins by a character
# that is a short option of an argument the script knows about.
# This is required in order to support getopts-like short options grouping.
begins_with_short_option() {
    local first_option all_short_options='ftiwh'
    first_option="${1:0:1}"
    test "$all_short_options" = "${all_short_options/$first_option/}" && return 1 || return 0
}

# THE DEFAULTS INITIALIZATION - OPTIONALS
_arg_file=
_arg_text=
_arg_caseInsensitive="false"
_arg_wholeWord="false"

# Help text function for when invalid input is encountered
print_help() {
    printf '%s\n' "Alert when the specified Text is found in a text file."
    printf 'Usage: %s [-f|--file [path to file]] [-t|--text [text to search]] [-i|--caseInsensitive <true|false>] [-w|--wholeWord <true|false>] [-h|--help]\n' "$0"
    printf '\t%s\n' "-f, --file: path to a log file"
    printf '\t%s\n' "-t, --text: text to alert when found"
    printf '\t%s\n' "-i, --caseInsensitive: search text with case insensitivity (default: false)"
    printf '\t%s\n' "-w, --wholeWord: search for text as a whole word (default: false)"
    printf '\t%s\n' "-h, --help: Prints help"
}

# Grabbing the parameters and parsing through them.
parse_commandLine() {
    while test $# -gt 0; do
        _key="$1"
        case "$_key" in
        -f | --file)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_file="$2"
            shift
            ;;
        --file=*)
            _arg_file="${_key##--file=}"
            ;;
        -f*)
            _arg_file="${_key##-f}"
            ;;
        -t | --text)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_text="$2"
            shift
            ;;
        --text=*)
            _arg_text="${_key##--text=}"
            ;;
        -t*)
            _arg_text="${_key##-t}"
            ;;
        -i | --caseInsensitive)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_caseInsensitive="$2"
            shift
            ;;
        --caseInsensitive=*)
            _arg_caseInsensitive="${_key##--caseInsensitive=}"
            ;;
        -i*)
            _arg_caseInsensitive="${_key##-i}"
            ;;
        -w | --wholeWord)
            test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
            _arg_wholeWord="$2"
            shift
            ;;
        --wholeWord=*)
            _arg_wholeWord="${_key##--wholeWord=}"
            ;;
        -w*)
            _arg_wholeWord="${_key##-w}"
            ;;
        -h | --help)
            print_help
            exit 0
            ;;
        -h*)
            print_help
            exit 0
            ;;
        *)
            _PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
            ;;
        esac
        shift
    done
}

parse_commandLine "$@"

text=$_arg_text
file=$_arg_file
caseInsensitive=$_arg_caseInsensitive
wholeWord=$_arg_wholeWord

# Check if Script Variables where used and overwrite command line parameters
if [[ -n "${textToMatch}" ]]; then
    text=$textToMatch
fi
if [[ -n "${textFile}" ]]; then
    file=$textFile
fi
if [[ -n "${matchWholeWord}" ]]; then
    wholeWord=$matchWholeWord
fi
if [[ -n "${insensitiveToCase}" ]]; then
    caseInsensitive=$insensitiveToCase
fi

# Check if text is not an empty string
if [[ -z "${text}" ]]; then
    echo "[Error] Text not specified"
    exit 2
fi

# Check if text is not an empty string
if [[ -z "${file}" ]]; then
    echo "[Error] File not specified"
    exit 2
fi

# Does file exit and is readable
if [ -f "${file}" ]; then
    echo "[Info] File \"${file}\" exists"
    if [ -r "${file}" ]; then
        echo "[Info] File \"${file}\" is readable"
    else
        echo "[Error] File \"${file}\" is not readable"
        exit 2
    fi
else
    echo "[Error] File \"${file}\" does not exists"
    exit 2
fi

# Detect
count=0
if [[ "${wholeWord}" == "true" ]]; then
    if [[ "${caseInsensitive}" == "true" ]]; then
        count=$(grep -c -i -n -w "$text" "$file")
    else
        count=$(grep -c -n -w "$text" "$file")
    fi
else
    if [[ "${caseInsensitive}" == "true" ]]; then
        count=$(grep -c -i -n -e "$text" "$file")
    else
        count=$(grep -c -n -e "$text" "$file")
    fi
fi

# Alert
if ((count > 0)); then
    echo "[Alert] Found text in file"
    exit 1
else
    echo "[Info] Not found text in file"
    exit 0
fi

 

Comprendere lo script

Lo script fornito è uno script Bash progettato per cercare un testo specifico all’interno di un file di log e attivare un avviso se tale testo viene trovato. Consente agli utenti di personalizzare i parametri di ricerca, ad esempio se la ricerca deve essere sensibile alle maiuscole o se deve corrispondere solo a parole intere. Ecco una descrizione dettagliata del funzionamento dello script.

Inizializzazione dello script

Lo script per cercare un testo nei file di log su macOS inizia definendo alcune funzioni per gestire gli errori, verificare la validità degli argomenti e visualizzare le informazioni di aiuto. La funzione die(), per esempio, viene utilizzata per terminare lo script e visualizzare un messaggio di errore se qualcosa va storto. Questa funzione stampa anche il testo di aiuto se viene fornita l’opzione –help.

Impostazione dei parametri predefiniti

Lo script per cercare un testo nei file di log su macOS inizializza diversi parametri predefiniti:

• _arg_file: Memorizza il percorso del file di log da cercare.
• _arg_text: Contiene il testo da cercare all’interno del file di log.
• _arg_caseInsensitive: Determina se la ricerca non debba essere sensibile alle maiuscole e alle minuscole.
• _arg_wholeWord: Specifica se la ricerca deve corrispondere solo a parole intere.

Questi parametri possono essere modificati dall’utente tramite argomenti della riga di comando durante l’esecuzione dello script per cercare un testo nei file di log su macOS.

Parsing degli argomenti della riga di comando

La funzione parse_commandLine() è responsabile del parsing degli argomenti della riga di comando passati allo script. Supporta diverse opzioni, come –file per specificare il file di log, –text per definire il testo di ricerca e –caseInsensitive e –wholeWord per personalizzare il comportamento della ricerca.

Se mancano i parametri richiesti, lo script per cercare un testo nei file di log su macOS termina con un messaggio di errore. Questo assicura che lo script venga eseguito con tutte le informazioni necessarie.

Convalida degli input e accessibilità dei file

Prima di eseguire la ricerca, lo scriptper cercare un testo nei file di log su macOS convalida gli input per verificare che non siano vuoti e controlla se il file specificato esiste ed è leggibile. Se il file non esiste o non è accessibile, lo script esce con un messaggio di errore, evitando un’esecuzione inutile.

Ricerca nel file di log

La funzionalità principale dello script consiste nella capacità di effettuare una ricerca nei file di log in base ai parametri forniti. Lo script per cercare un testo nei file di log su macOS utilizza il comando grep, un potente strumento per la ricerca di testo nei file, per eseguire la ricerca. A seconda delle opzioni selezionate, grep cercherà il testo con sensibilità a maiuscole e minuscole oppure no, e cercherà una corrispondenza con l’intera parola o parte di essa.

• Se –wholeWord è impostato su true, lo script aggiunge il flag -w a grep, assicurando che vengano cercate corrispondenze solo con le parole intere.
• Se –caseInsensitive è su True, lo script utilizza il flag -i per non fare differenza tra maiuscole e minuscole durante la ricerca.

Attivazione degli avvisi

Una volta completata la ricerca, lo script conta il numero di corrispondenze trovate nel file di log. Se non vengono rilevate delle corrispondenze, lo script attiva un avviso stampando il messaggio [Alert] Found text in file. If no matches are found, it prints [Info] Testo non trovato nel file. Questo approccio diretto garantisce che gli utenti siano immediatamente informati se il testo che stanno monitorando compare nel file di log.

Applicazione concreta

Immagina un professionista IT che gestisce una server farm in cui è fondamentale monitorare i messaggi di errore specifici nei file di log. Utilizzando questo script per cercare un testo nei file di log su macOS, può essere avvisato automaticamente ogni volta che un particolare codice di errore o messaggio appare nei log, in modo da poter intervenire immediatamente. Per esempio, se nei log viene trovato il testo “disk failure”, lo script può attivare un avviso, consentendo al team IT di risolvere il problema prima che si trasformi in un guasto critico del sistema.

Confronto con altri metodi

Sebbene questo script fornisca un modo semplice ed efficace per monitorare i file di log, con altri metodi è possibile ottenere risultati simili. Per esempio, i sistemi di gestione dei log più avanzati, come Splunk o lo stack ELK, offrono un’analisi completa dei log, compreso il monitoraggio in tempo reale, le query complesse e le integrazioni con altri sistemi. Tuttavia, queste soluzioni richiedono spesso più risorse e possono essere eccessive per ambienti più piccoli o per casi d’uso specifici in cui è sufficiente un semplice script Bash.

Domande frequenti

1. Questo script può essere utilizzato su sistemi operativi diversi da macOS?

Sì, questo script è scritto in Bash, che è disponibile sulla maggior parte dei sistemi operativi Unix-like, compreso Linux. Tuttavia, potrebbero essere necessari alcune modifiche a seconda dell’ambiente specifico.

2. Come posso modificare lo script per cercare più file contemporaneamente?

Puoi modificare lo script per eseguire iterazioni su più file espandendo l’opzione –file in modo da accettare un elenco di file o directory. Lo script può quindi iterare su ogni file ed eseguire la ricerca.

3. Cosa succede se il file di log è molto grande?

Per i file di log molto grandi, le prestazioni possono diventare un problema. In questi casi, valuta la possibilità di ottimizzare la ricerca limitando il numero di righe ricercate o utilizzando strumenti più avanzati come awk o sistemi di gestione dei log.

Implicazioni per la sicurezza informatica

Automatizzando il monitoraggio dei file di log, questo script può contribuire a migliorare la sicurezza informatica, garantendo che i problemi critici vengano individuati e affrontati tempestivamente. Per esempio, il rilevamento di tentativi di accesso non autorizzati o di attività di malware nei log può aiutare a prevenire le violazioni della sicurezza e a ridurre il rischio di perdita di dati.

Best practice

Quando utilizzi questo script per cercare un testo nei file di log su macOS, tieni a mente le seguenti best practice:

• Aggiorna regolarmente lo script per garantire la compatibilità con il tuo ambiente.
• Utilizza parametri di ricerca chiari e specifici per evitare falsi positivi.
• Implementa ulteriori meccanismi di logging o di avviso come soluzioni complementari allo script.

Considerazioni finali

Per i professionisti IT e gli MSP, strumenti come questo script per cercare un testo nei file di log su macOS sono preziosi per automatizzare le attività di routine e garantire l’integrità del sistema. Inserendo tali script nel tuo flusso di lavoro, potrai concentrarti su attività più strategiche, mantenendo la certezza che i problemi critici non passeranno inosservati. NinjaOne offre una suite di strumenti che possono migliorare ulteriormente le capacità di gestione dell’IT, fornendo ulteriori livelli di automazione, monitoraggio e sicurezza a supporto delle operazioni IT.