Comment surveiller les fichiers journaux sur macOS avec un script Bash personnalisé ?

Dans le monde informatique actuel, il est essentiel de surveiller et de gérer efficacement les fichiers journaux pour maintenir l’intégrité du système et garantir la sécurité. Que vous soyez un professionnel de l’informatique ou un fournisseur de services gérés (MSP), la possibilité de rechercher et d’alerter rapidement sur un texte spécifique dans un fichier journal peut être un outil puissant dans votre arsenal. Cet article de blog explore un script Bash personnalisé conçu pour alerter les utilisateurs lorsqu’un texte est détecté dans un fichier journal sur macOS.

L’importance de la surveillance des fichiers journaux

Les fichiers journaux sont un élément essentiel du fonctionnement et de la maintenance des systèmes informatiques. Ils contiennent des enregistrements d’événements, de processus et d’erreurs qui se produisent sur un ordinateur ou un réseau. L’analyse des fichiers journaux permet aux professionnels de l’informatique d’identifier les problèmes, d’en rechercher la cause d’origine et de garantir la conformité aux exigences réglementaires. Toutefois, l’examen manuel de ces fichiers pour trouver des informations pertinentes peut prendre beaucoup de temps et être sujet à des erreurs humaines.

C’est là que l’automatisation entre en jeu. L’automatisation du processus de surveillance des fichiers journaux et le déclenchement d’alertes en cas de détection d’un texte spécifique permettent de gagner du temps et de réduire le risque de négliger des problèmes critiques. Le script dont nous allons parler est une solution simple mais efficace pour y parvenir sur macOS.

Le script :

#!/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

 

Comprendre le script

Le script fourni est un script Bash conçu pour rechercher un texte spécifique dans un fichier journal et déclencher une alerte si ce texte est trouvé. Il permet aux utilisateurs de personnaliser les paramètres de recherche, par exemple en précisant si la recherche doit tenir compte des majuscules ou des minuscules ou si elle ne doit porter que sur des mots entiers. Voici une description détaillée du fonctionnement du script.

Initialisation du script

Le script commence par définir quelques fonctions pour gérer les erreurs, vérifier la validité des arguments et afficher des informations d’aide. La fonction die(), par exemple, est utilisée pour mettre fin au script et afficher un message d’erreur en cas de problème. Cette fonction imprime également le texte d’aide si l’option –help est fournie.

Paramètres par défaut

Le script initialise plusieurs paramètres par défaut :

• _arg_file: Enregistre le chemin d’accès au fichier journal à rechercher.
• _arg_text: Contient le texte à rechercher dans le fichier journal.
• _arg_caseInsensitive: Détermine si la recherche doit prendre en compte les majuscules et minuscules
• _arg_wholeWord: Indique si la recherche ne doit porter que sur des mots entiers.

Ces paramètres peuvent être modifiés par l’utilisateur au moyen d’arguments de ligne de commande lors de l’exécution du script.

Analyse des arguments de la ligne de commande

La fonction parse_commandLine() est chargée d’analyser les arguments de la ligne de commande transmis au script. Il prend en charge plusieurs options, telles que –file pour spécifier le fichier journal, –text pour définir le texte de recherche, et -caseInsensitive et –wholeWord pour personnaliser le comportement de la recherche.

Si l’un des paramètres requis est manquant, le script se termine par un message d’erreur. Cela permet de s’assurer que le script s’exécute avec toutes les informations nécessaires.

Validation des entrées et accessibilité des fichiers

Avant d’effectuer la recherche, le script valide les entrées pour s’assurer qu’elles ne sont pas vides et vérifie si le fichier spécifié existe et est lisible. Si le fichier n’existe pas ou n’est pas accessible, le script se termine par un message d’erreur, évitant ainsi toute exécution inutile.

Recherche dans le fichier journal

La fonctionnalité principale du script réside dans sa capacité à rechercher le fichier journal en fonction des paramètres fournis. Le script utilise la commande grep, un outil puissant de recherche de texte dans les fichiers, pour effectuer la recherche. En fonction des options sélectionnées, grep recherchera le texte en tenant compte ou non des majuscules et en recherchant le mot entier ou une partie du mot.

• Si –wholeWord est défini à true, le script ajoute le flag -w à grep, garantissant que seuls les mots entiers sont recherchés.
• Si l’option –caseInsensitive est défini à true, le script utilise l’option -i pour ignorer les majuscules et minuscules lors de la recherche.

Déclenchement des alertes

Une fois la recherche terminée, le script compte le nombre de correspondances trouvées dans le fichier journal. Si des correspondances sont détectées, le script déclenche une alerte “[Alert] Found text in file”. Si aucune correspondance n’est trouvée, il affiche “[Info] Not found text in file”. Cette approche simple garantit que les utilisateurs sont immédiatement informés si le texte qu’ils surveillent apparaît dans le fichier journal.

Application dans le monde réel

Imaginez un professionnel de l’informatique gérant un parc de serveurs où il est crucial de surveiller des messages d’erreur spécifiques dans les fichiers journaux. En déployant ce script, il peut être automatiquement alerté lorsqu’un code d’erreur ou un message particulier apparaît dans les journaux, ce qui lui permet de prendre des mesures immédiates. Par exemple, si le texte “panne de disque” est trouvé dans les journaux, le script peut déclencher une alerte, permettant à l’équipe informatique de traiter le problème avant qu’il ne se transforme en panne de système critique.

Comparaison avec d’autres méthodes

Bien que ce script constitue un moyen simple et efficace de surveiller les fichiers journaux, d’autres méthodes permettent d’obtenir des résultats similaires. Par exemple, des systèmes de gestion de journaux plus avancés comme Splunk ou ELK stack offrent une analyse complète des journaux, y compris une surveillance en temps réel, des requêtes complexes et des intégrations avec d’autres systèmes. Toutefois, ces solutions nécessitent souvent plus de ressources et peuvent s’avérer excessives pour les petits environnements ou les cas d’utilisation spécifiques pour lesquels un simple script Bash suffit.

Questions fréquemment posées

1. Ce script peut-il être utilisé sur d’autres systèmes d’exploitation que macOS ?

Oui, ce script est écrit en Bash, qui est disponible sur la plupart des systèmes d’exploitation de type Unix, y compris Linux. Toutefois, certains ajustements peuvent être nécessaires en fonction de l’environnement spécifique.

2. Comment puis-je modifier le script pour qu’il recherche plusieurs fichiers à la fois ?

Vous pouvez modifier le script pour qu’il parcoure en boucle plusieurs fichiers en étendant l’option –file pour qu’elle accepte une liste de fichiers ou de répertoires. Le script peut alors parcourir chaque fichier et effectuer la recherche.

3. Que se passe-t-il si le fichier journal est très volumineux ?

Pour les fichiers journaux très volumineux, les performances peuvent devenir un problème. Dans ce cas, il faut envisager d’optimiser la recherche en limitant le nombre de lignes recherchées ou en utilisant des outils plus avancés comme awk ou des systèmes de gestion des journaux.

Implications pour la sécurité informatique

En automatisant la surveillance des fichiers journaux, ce script peut contribuer à améliorer la sécurité informatique en garantissant que les problèmes critiques sont détectés et traités rapidement. Par exemple, la détection des tentatives d’accès non autorisé ou de l’activité des logiciels malveillants dans les journaux peut aider à prévenir les failles de sécurité et à réduire le risque de perte de données.

Bonnes pratiques

Lors de l’utilisation de ce script, il est important de suivre les bonnes pratiques suivantes :

• Mettez régulièrement à jour le script pour assurer sa compatibilité avec votre environnement.
• Utilisez des paramètres de recherche clairs et spécifiques pour éviter les faux positifs.
• Implémentez des mécanismes supplémentaires de journalisation ou d’alerte pour compléter le script.

Conclusion

Pour les professionnels de l’informatique et les entreprises MSP, les outils comme ce script sont d’une valeur inestimable pour automatiser les tâches de routine et garantir la santé du système. En intégrant ces scripts dans votre flux de travail, vous pouvez vous concentrer sur des activités plus stratégiques tout en ayant la certitude que les problèmes critiques ne passeront pas inaperçus. NinjaOne offre une suite d’outils qui peuvent encore améliorer encore plus vos capacités de gestion informatique, en fournissant des couches supplémentaires d’automatisation, de surveillance et de sécurité pour soutenir vos opérations informatiques.