Überwachung von Protokolldateien unter macOS mit einem benutzerdefinierten Bash-Skript

In der heutigen IT-Welt ist das effiziente Monitoring und Management von Protokolldateien entscheidend für die Aufrechterhaltung des Systemzustands und die Gewährleistung der Sicherheit.  Ob Sie ein IT-Experte oder ein Managed Service Provider (MSP) sind, die Möglichkeit, einen bestimmten Text in einer Protokolldatei schnell zu suchen und zu melden, kann ein leistungsstarkes Tool sein. In diesem Blogbeitrag wird ein benutzerdefiniertes Bash-Skript vorgestellt, das Benutzer:innen benachrichtigt, wenn ein bestimmter Text in einer Protokolldatei unter macOS entdeckt wird.

Die Bedeutung des Monitorings von Protokollen

Protokolle sind eine wichtige Komponente für den Betrieb und die Wartung von IT-Systemen. Sie enthalten Aufzeichnungen über Ereignisse, Prozesse und Fehler, die auf einem Computer oder in einem Netzwerk auftreten. Durch die Analyse von Protokollen können IT-Experten Probleme erkennen, die Ursache von Problemen aufspüren und die Compliance sicherstellen. Das manuelle Durchsuchen dieser Dateien nach relevanten Informationen kann jedoch zeitaufwändig und anfällig für menschliche Fehler sein.

Hier kommt die Automatisierung ins Spiel. Die Automatisierung des Monitorings von Protokollen und die Auslösung von Meldungen, wenn ein bestimmter Text gefunden wird, kann Zeit sparen und das Risiko verringern, dass kritische Probleme übersehen werden. Das thematisierte Skript ist eine einfache, aber effektive Lösung, um dies unter macOS zu erreichen.

Das Skript:

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

 

Verständnis des Skripts

Das mitgelieferte Skript ist ein Bash-Skript, das nach einem bestimmten Text in einem Protokoll sucht und die Anwender:innen benachrichtigt, wenn dieser Text gefunden wird. Die Benutzer:innen können die Suchparameter anpassen, z. B. ob bei der Suche Groß- und Kleinschreibung beachtet werden soll oder ob nur ganze Wörter gefunden werden sollen. Hier finden Sie eine detaillierte Aufschlüsselung der Funktionsweise des Skripts.

Skript-Initialisierung

Das Skript beginnt mit der Definition einiger Funktionen zur Fehlerbehandlung, zur Prüfung auf gültige Argumente und zur Anzeige von Hilfeinformationen. Die Funktion die() wird zum Beispiel verwendet, um das Skript zu beenden und eine Fehlermeldung anzuzeigen, wenn etwas schiefläuft. Diese Funktion gibt auch den Hilfetext aus, wenn die Option –help angegeben ist.

Standard-Parametereinstellung

Das Skript initialisiert mehrere Standardparameter:

• _arg_file: Speichert den Pfad zu dem zu durchsuchenden Protokoll.
• _arg_text: Enthält den Text, nach dem im Protokoll gesucht werden soll.
• _arg_caseInsensitive: Legt fest, ob bei der Suche die Groß- und Kleinschreibung nicht berücksichtigt werden soll.
• _arg_wholeWord: Bestimmt, ob die Suche nur mit ganzen Wörtern übereinstimmen soll.

Diese Parameter können von den Benutzer:innen über Befehlszeilenargumente bei der Ausführung des Skripts geändert werden.

Parsen von Befehlszeilenargumenten

Die Funktion parse_commandLine() ist für das Parsen der an das Skript übergebenen Befehlszeilenargumente zuständig. Es unterstützt mehrere Optionen, wie –file zur Angabe der Protokolldatei, –text zur Definition des Suchtextes und –caseInsensitive und –wholeWord zur Anpassung des Suchverhaltens.

Fehlen die erforderlichen Parameter, wird das Skript mit einer Fehlermeldung beendet. Dadurch wird sichergestellt, dass das Skript mit allen erforderlichen Informationen ausgeführt wird.

Validierung von Eingaben und Dateizugänglichkeit

Bevor das Skript die Suche durchführt, validiert es die Eingaben, um zu gewährleisten, dass sie nicht leer sind, und prüft, ob die angegebene Datei existiert und ausführbar ist. Wenn die Datei nicht existiert oder nicht zugänglich ist, wird das Skript mit einer Fehlermeldung beendet, um eine unnötige Ausführung zu verhindern.

Durchsuchen der Protokolldatei

Die Kernfunktionalität des Skripts besteht in der Fähigkeit, die Protokolldatei anhand der angegebenen Parameter zu durchsuchen. Das Skript verwendet den Befehl grep, ein leistungsfähiges Tool zum Durchsuchen von Text in Dateien, um die Suche durchzuführen. Je nach den gewählten Optionen sucht grep nach dem Text mit oder ohne Berücksichtigung der Groß- und Kleinschreibung und findet entweder das ganze Wort oder einen Teil des Wortes.

• Wenn –wholeWord auf true gesetzt ist, fügt das Skript das Flag -w zu grep hinzu, um sicherzustellen, dass nur ganze Wörter gefunden werden.
• Wenn –caseInsensitive eingegeben ist, verwendet das Skript das Flag -i, um die Groß- und Kleinschreibung bei der Suche zu ignorieren.

Benachrichtigung

Nach Abschluss der Suche zählt das Skript die Anzahl der gefundenen Treffer im Protokoll. Wenn Übereinstimmungen gefunden werden, löst das Skript eine Meldung aus, indem es [Alert] Found text in file ausgibt. Wird keine Übereinstimmung gefunden, wird [Info] Not found text in file angezeigt. Dieser einfache Ansatz gewährleistet, dass die Benutzer:innen sofort informiert werden, wenn der von ihnen überwachte Text in der Protokolldatei erscheint.

Anwendung in der Praxis

Stellen Sie sich einen IT-Experten vor, der eine Serverfarm verwaltet, in der es entscheidend ist, bestimmte Fehlermeldungen in den Protokollen zu überwachen. Durch den Einsatz dieses Skripts kann er automatisch benachrichtigt werden, wenn ein bestimmter Fehlercode oder eine bestimmte Meldung in den Protokollen auftaucht, sodass er sofort Maßnahmen ergreifen kann. Wird beispielsweise der Text “disk failure” in den Protokollen gefunden, kann das Skript eine Warnmeldung auslösen, sodass das IT-Team das Problem beheben kann, bevor es zu einem kritischen Systemausfall eskaliert.

Vergleich mit anderen Methoden

Mithilfe dieses Skripts kann man zwar auf eine einfache und effektive Weise Protokolldateien unter macOS überwachen, aber auch andere Methoden können ähnliche Ergebnisse erzielen. So bieten beispielsweise leistungsfähigere Protokoll-Management-Systeme wie Splunk oder ELK Stack umfassende Protokollanalysen, einschließlich Echtzeitüberwachung, komplexer Abfragen und Integrationen mit anderen Systemen. Diese Lösungen erfordern jedoch oft mehr Ressourcen und können für kleinere Umgebungen oder spezielle Anwendungsfälle, in denen ein einfaches Bash-Skript ausreicht, zu aufwendig sein.

Häufig gestellte Fragen

1. Kann dieses Skript auch auf anderen Betriebssystemen als macOS verwendet werden?

Ja, dieses Skript ist in Bash geschrieben, das auf den meisten Unix-ähnlichen Betriebssystemen, einschließlich Linux, verfügbar ist. Je nach Umgebung können jedoch einige Anpassungen erforderlich sein.

2. Wie kann ich das Skript so ändern, dass es mehrere Dateien auf einmal durchsucht?

Sie können das Skript so ändern, dass es mehrere Dateien abarbeitet, indem Sie die Option –file so erweitern, dass sie eine Liste von Dateien oder Verzeichnissen akzeptiert. Das Skript kann dann die einzelnen Dateien durchlaufen und die Suche durchführen.

3. Was passiert, wenn das Protokoll sehr groß ist?

Bei sehr großen Protokollen kann die Leistung ein Problem werden. In solchen Fällen sollten Sie die Suche optimieren, indem Sie die Anzahl der zu durchsuchenden Zeilen begrenzen oder leistungsfähigere Tools wie awk oder Protokoll-Management-Systeme verwenden.

Auswirkungen auf die IT-Sicherheit

Durch die Automatisierung des Monitorings von Protokolldateien kann dieses Skript dazu beitragen, die IT-Sicherheit zu verbessern, indem es garantiert, dass kritische Probleme sofort erkannt und behoben werden. Die Erkennung von unbefugten Zugriffsversuchen oder Malware-Aktivitäten in Protokollen kann beispielsweise dazu beitragen, Sicherheitsverletzungen zu verhindern und das Risiko von Datenverlusten zu verringern.

Best Practices

Beachten Sie bei der Verwendung dieses Skripts die folgenden Best Practices:

• Aktualisieren Sie das Skript regelmäßig, um die Kompatibilität mit Ihrer Umgebung zu gewährleisten.
• Verwenden Sie eindeutige und spezifische Textsuchparameter, um Fehlalarme zu vermeiden.
• Implementieren Sie zusätzliche Protokollierungs- oder Benachrichtigungsmechanismen, um das Skript zu ergänzen.

Fazit

Für IT-Experten und MSPs sind Tools wie dieses Skript von unschätzbarem Wert, um Routineaufgaben zu automatisieren und die Systemstabilität aufrechtzuerhalten. Durch die Integration solcher Skripte in Ihren Arbeitsablauf können Sie sich auf strategischere Aktivitäten konzentrieren und gleichzeitig darauf vertrauen, dass kritische Probleme nicht unbemerkt bleiben. NinjaOne bietet eine Reihe von Tools, die Ihre IT-Management-Fähigkeiten weiter verbessern und zusätzliche Automatisierungs-, Monitoring- und Sicherheitsebenen zur Unterstützung Ihres IT-Betriebs bereitstellen.