Toggle sidebar

Synology Docker Logging driver

W

wIllson

Benutzer
Registriert
29. Mai 2020
Beiträge
15
Reaktionspunkte
0
Punkte
1
Hallo Leute,
ich habe einen Container in Docker laufen, der sehr viel nach STDOUT loggt (10mb pro Tag). Die log.db wird dann sehr schnell sehr groß.
Synology nutzt einen propritären Log-Driver ("db"), sodass man die letzten Logeinträge im Webinterface begutachten kann, was ich sehr schön finde.
Gerne würde ich eine Log-Rotation nutzen, z.B.
- Logeinträge für die letzten 3 Tage behalten
- Logfile maximum 100mb einstellen
Wisst ihr, welche Parameter ich in den Log-opts einstellen muss, damit das Logfile nicht ins unermessliche wächst? (max-file/max-size?)
 
Und wieso teilst du sie dann nicht für Leute die das selbe vor haben?
Hauptsache selber Hilfe bekommen....
 
ja Entschuldigung ich habe das Skript noch angepasst und Kommentare hinzugefügt um es für andere nachvollziehbar und ordentlich lesbar zu machen

also hier ist die Funktionsweise des Skriptes:

es werden alle Docker Container abgerufen und die Logeinträge bereinigt. Die Zahl in DEFAULT_DAYS ist für Container, die nicht explizit in CONTAINERS_DAYS angegeben werden oder keine Tage zugewiesen sind. Diese Zahl bestimmt die Standard-Tage welche Logeinträge behalten werden sollen.

alle in CONTAINERS_DAYS angegebenen Containernamen und Tage werden gesondert behandelt. Hier ein Beispiel einer Config:

Code: 
DEFAULT_DAYS=365



declare -A CONTAINERS_DAYS=(
    ["Container_A"]=7
    ["Container-B"]=14
    ["Container-C"]

    # Weitere Container und deren Tage kannst du hier hinzufügen
)
und hier die Bereinigungsbeschreibung zu dieser Config:
  • Logeinträge des Containers mit dem Namen Container_A werden bereinigt - Logeinträge der letzten 7 Tage werden beibehalten
  • Logeinträge des Containers mit dem Namen Container_B werden bereinigt - Logeinträge der letzten 14 Tage werden beibehalten
  • Logeinträge des Containers mit dem Namen Container_C werden bereinigt - Logeinträge der letzten 365 Tage werden beibehalten
  • Logeinträge aller anderen Container werden ebenso bereinigt - Logeinträge der letzten 365 Tage werden beibehalten
Das Skript am besten einfach direkt in eine neue Aufgabe der Synology Aufgabenplanung einfügen (unbedingt als root- Benutzer ausführen!!!) und einen Zeitplan festlegen. Natürlich kann auch eine Python-Datei (.py) mit dem Inhalt des Skriptes angelegt werden und in der Aufgabenplanung aufgerufen bzw. ausgeführt werden.

Hier ist das Skript für die direkte Eingabe des Skriptes in der Aufgabe vom Aufgabenplaner:

Python: 
python3 - <<EOF
import subprocess
import sqlite3
from datetime import datetime, timedelta

# ANSI-Farbcodes für farbige Ausgaben
RED = '\033[0;31m'
BLUE = '\033[0;34m'
GREEN = '\033[0;32m'
NC = '\033[0m'  # ANSI-Code zum Zurücksetzen der Farbe

# Definiere Container und die Anzahl der Tage, die für jeden Container beibehalten werden sollen
CONTAINERS_DAYS = {
    "CONTAINERNAME_A": 7,
    "CONTAINERNAME_B": 14,
    # Weitere Container und deren Tage kannst du hier hinzufügen
}

# Standardanzahl an Tagen für alle anderen Container, die nicht in CONTAINERS_DAYS enthalten sind
DEFAULT_DAYS = 365

def get_all_containers():
    """Gibt eine Liste aller Container-Namen zurück."""
    result = subprocess.run(["docker", "ps", "-a", "--format", "{{.Names}}"], capture_output=True, text=True)
    return result.stdout.splitlines()

def get_log_path(container_name):
    """Gibt den Log-Pfad des Containers zurück."""
    result = subprocess.run(["docker", "inspect", "--format", "{{.LogPath}}", container_name], capture_output=True, text=True)
    return result.stdout.strip()

def cleanup_logs(db_path, days_to_keep, container_name):
    try:
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)

        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))
        conn.commit()
        conn.close()

        print(f"{GREEN}Finished:{NC} Log entries older than {days_to_keep} days have been cleaned up for the container {GREEN}'{container_name}'{NC} at: {db_path}.")
    except Exception as e:
        print(f"{RED}Warning:{NC} Log database file not found for container '{container_name}' at {db_path}")
        print(f"{RED}Error details:{NC} {e}")

# Alle Container auflisten
containers = get_all_containers()

# Überprüfung auf nicht existierende Container in CONTAINERS_DAYS
for container_name in CONTAINERS_DAYS:
    if container_name not in containers:
        print(f"{RED}Warning:{NC} Container '{container_name}' doesn't exist. Please check container name...")

# Schleife über alle Container auf dem System
for container_name in containers:
    # Überprüfen, ob der Container spezielle Tage hat oder die Standardtage verwenden soll
    days_to_keep = CONTAINERS_DAYS.get(container_name, DEFAULT_DAYS)

    # Ermitteln des Log-DB-Pfads für den aktuellen Container
    log_path = get_log_path(container_name)

    if not log_path:
        print(f"{RED}Warning:{NC} No log file for container '{container_name}' found. Skipping container '{container_name}'...")
        continue

    cleanup_logs(log_path, days_to_keep, container_name)
EOF

wenn du es bevorzugst eine eigene Skriptdatei zu erstellen muss in der Aufgabenplanung folgendes eingegeben werden:

Code: 
python /pfad/zur/python/datei/DATEINAME.py

und hier der Code für die eigene Skriptdatei:

Python: 
import subprocess
import sqlite3
from datetime import datetime, timedelta

# ANSI-Farbcodes für farbige Ausgaben
RED = '\033[0;31m'
BLUE = '\033[0;34m'
GREEN = '\033[0;32m'
NC = '\033[0m'  # ANSI-Code zum Zurücksetzen der Farbe

# Definiere Container und die Anzahl der Tage, die für jeden Container beibehalten werden sollen
CONTAINERS_DAYS = {
    "CONTAINERNAME_A": 7,
    "CONTAINERNAME_B": 14,
    # Weitere Container und deren Tage kannst du hier hinzufügen
}

# Standardanzahl an Tagen für alle anderen Container, die nicht in CONTAINERS_DAYS enthalten sind
DEFAULT_DAYS = 365

def get_all_containers():
    """Gibt eine Liste aller Container-Namen zurück."""
    result = subprocess.run(["docker", "ps", "-a", "--format", "{{.Names}}"], capture_output=True, text=True)
    return result.stdout.splitlines()

def get_log_path(container_name):
    """Gibt den Log-Pfad des Containers zurück."""
    result = subprocess.run(["docker", "inspect", "--format", "{{.LogPath}}", container_name], capture_output=True, text=True)
    return result.stdout.strip()

def cleanup_logs(db_path, days_to_keep, container_name):
    try:
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)

        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))
        conn.commit()
        conn.close()

        print(f"{GREEN}Finished:{NC} Log entries older than {days_to_keep} days have been cleaned up for the container {GREEN}'{container_name}'{NC} at: {db_path}.")
    except Exception as e:
        print(f"{RED}Warning:{NC} Log database file not found for container '{container_name}' at {db_path}")
        print(f"{RED}Error details:{NC} {e}")

# Alle Container auflisten
containers = get_all_containers()

# Überprüfung auf nicht existierende Container in CONTAINERS_DAYS
for container_name in CONTAINERS_DAYS:
    if container_name not in containers:
        print(f"{RED}Warning:{NC} Container '{container_name}' doesn't exist. Please check container name...")

# Schleife über alle Container auf dem System
for container_name in containers:
    # Überprüfen, ob der Container spezielle Tage hat oder die Standardtage verwenden soll
    days_to_keep = CONTAINERS_DAYS.get(container_name, DEFAULT_DAYS)

    # Ermitteln des Log-DB-Pfads für den aktuellen Container
    log_path = get_log_path(container_name)

    if not log_path:
        print(f"{RED}Warning:{NC} No log file for container '{container_name}' found. Skipping container '{container_name}'...")
        continue

    cleanup_logs(log_path, days_to_keep, container_name)
 
  • Like
Reaktionen: DaveR, DrDeath und ctrlaltdelete
Schönes Script !

Wird die log.db der betroffenen Container damit auch verkleinert ? (DB shrink, vacuum?)

Ich habe mir einen bestimmtes Container Log angesehen, aber die Dateigröße selbst blieb nach dem Scriptlauf gleich.

Code: 
Finished: Log entries older than 10 days have been cleaned up for the container 'watchtower' at: /volume1/@docker/containers/f6def2e2d65c75a41985abc0f19dddfdbf31e4ca4250cfacb46e53f5ddb661c1/log.db


Dieser Code kann dazu benutzt werden die db zu shrinken:

SUCHE:
Python: 
        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))
        conn.commit()
        conn.close()

DANACH hinzufügen:
Python: 
        # SQLite Befehl dient zum Verkleinern der Datenbank nach dem vorherigen Löschen der alten Datensätze
        conn = sqlite3.connect(db_path)
        conn.execute("VACUUM")
        conn.close()
 
Zuletzt bearbeitet:
  • Like
Reaktionen: ctrlaltdelete
Habe die Skripte angepasst und dein Skript hinzugefügt:

Hier ist das Skript für die direkte Eingabe des Skriptes in der Aufgabe vom Aufgabenplaner:

Python: 
#!/bin/bash

# ANSI-Farben für Textfarbe im Output
# Rot
RED='\033[0;31m'
# Blau
BLUE='\033[0;34m'
# Gelb
YELLOW='\033[0;33m'
# Grün
GREEN='\033[0;32m'
# ANSI-Farbcode für kein Format (zum Zurücksetzen der Farbe)
NC='\033[0m'

# Container-Namen und deren zu behaltende Tage
declare -A CONTAINERS_DAYS=(
    ["CONTAINERNAME_A"]=7
    ["CONTAINERNAME_B"]=14
    # Weitere Container und deren Tage kannst du hier hinzufügen
)

# Standardanzahl an Tagen für alle anderen Container die nicht in CONTAINERS_DAYS enthalten sind oder keine Tage angegeben sind
DEFAULT_DAYS=365

# Liste aller existierenden Container auf dem System abrufen
EXISTING_CONTAINERS=$(docker ps -a --format '{{.Names}}')

# Überprüfung auf nicht existierende Container in CONTAINERS_DAYS
for CONTAINER in "${!CONTAINERS_DAYS[@]}"; do
    if ! echo "$EXISTING_CONTAINERS" | grep -qw "$CONTAINER"; then
        echo -e "${RED}Warning:${NC} Container '$CONTAINER' doesnt exist. Please check Containername..."
    fi
done

# Schleife durch alle Container auf dem System
for CONTAINER in $EXISTING_CONTAINERS
do
    # Überprüfen, ob der Container spezielle Tage hat oder die Standardtage verwenden soll
    if [[ -v CONTAINERS_DAYS[$CONTAINER] ]]; then
        DAYS_TO_KEEP=${CONTAINERS_DAYS[$CONTAINER]}
    else
        DAYS_TO_KEEP=$DEFAULT_DAYS
    fi

    # Ermitteln des Log-DB-Pfads für den aktuellen Container
    DB_PATH=$(docker inspect --format='{{.LogPath}}' $CONTAINER 2>/dev/null)

    if [ -z "$DB_PATH" ]; then
        echo "${RED}Warning:${NC} No Logfile for Container '$CONTAINER' found. Skipping Container '$CONTAINER'..."
        continue
    fi

    if [ -f "$DB_PATH" ]; then
        echo "${BLUE}Info:${NC} Cleaning Logs for Container '$CONTAINER' (keeping $DAYS_TO_KEEP days of log entries)..."

        # Python-Skript ausführen, wenn die Datenbank existiert
        python3 - <<END
import sqlite3
from datetime import datetime, timedelta

def cleanup_logs(db_path, days_to_keep):
    # Verbindung zur Datenbank herstellen
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
   
    # Aktuelles Datum
    current_time = datetime.now()
   
    # Bereinigungsdatum berechnen
    cutoff_time = current_time - timedelta(days=days_to_keep)
   
    # SQL-Abfrage zum Löschen alter Einträge
    cursor.execute(
        "DELETE FROM log WHERE created < ?",
        (cutoff_time.isoformat(),)
    )
    # Datenbank um diese Einträge verkleinern
    conn.execute("VACUUM")
    # Änderungen speichern und Verbindung schließen
    conn.commit()
    conn.close()
   
    print(f"${GREEN}Finished:${NC} Log entries older than {days_to_keep} days have been cleaned up for the container ${GREEN}'$CONTAINER'${NC} at: {db_path}.")

# Parameter für das Python-Skript
db_path = "$DB_PATH"
days_to_keep = $DAYS_TO_KEEP

# Cleanup Funktion aufrufen
cleanup_logs(db_path, days_to_keep)
END
    else
        echo "${RED}Warnung:${NC} Log database file not found for container '$CONTAINER' at $DB_PATH"
    fi
done

und hier der Code für die eigene Skriptdatei:

Python: 
import subprocess
import sqlite3
from datetime import datetime, timedelta

# ANSI-Farbcodes für farbige Ausgaben
RED = '\033[0;31m'
BLUE = '\033[0;34m'
GREEN = '\033[0;32m'
NC = '\033[0m'  # ANSI-Code zum Zurücksetzen der Farbe

# Definiere Container und die Anzahl der Tage, die für jeden Container beibehalten werden sollen
CONTAINERS_DAYS = {
    "DynDNS": 31,
    # Weitere Container und deren Tage kannst du hier hinzufügen
}

# Standardanzahl an Tagen für alle anderen Container, die nicht in CONTAINERS_DAYS enthalten sind
DEFAULT_DAYS = 365

def get_all_containers():
    """Gibt eine Liste aller Container-Namen zurück."""
    result = subprocess.run(["docker", "ps", "-a", "--format", "{{.Names}}"], capture_output=True, text=True)
    return result.stdout.splitlines()

def get_log_path(container_name):
    """Gibt den Log-Pfad des Containers zurück."""
    result = subprocess.run(["docker", "inspect", "--format", "{{.LogPath}}", container_name], capture_output=True, text=True)
    return result.stdout.strip()

def cleanup_logs(db_path, days_to_keep, container_name):
    try:
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)

        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))
        # Datenbank um diese Einträge verkleinern
        conn.execute("VACUUM")
       
        conn.commit()
        conn.close()

        print(f"{GREEN}Finished:{NC} Log entries older than {days_to_keep} days have been cleaned up for the container {GREEN}'{container_name}'{NC} at: {db_path}.")
    except Exception as e:
        print(f"{RED}Warning:{NC} Log database file not found for container '{container_name}' at {db_path}")
        print(f"{RED}Error details:{NC} {e}")
   
# Alle Container auflisten
containers = get_all_containers()

# Überprüfung auf nicht existierende Container in CONTAINERS_DAYS
for container_name in CONTAINERS_DAYS:
    if container_name not in containers:
        print(f"{RED}Warning:{NC} Container '{container_name}' doesn't exist. Please check container name...")

# Schleife über alle Container auf dem System
for container_name in containers:
    # Überprüfen, ob der Container spezielle Tage hat oder die Standardtage verwenden soll
    days_to_keep = CONTAINERS_DAYS.get(container_name, DEFAULT_DAYS)

    # Ermitteln des Log-DB-Pfads für den aktuellen Container
    log_path = get_log_path(container_name)

    if not log_path:
        print(f"{RED}Warning:{NC} No log file for container '{container_name}' found. Skipping container '{container_name}'...")
        continue

    cleanup_logs(log_path, days_to_keep, container_name)
 
  • Like
Reaktionen: DaveR
  • Like
Reaktionen: XxX_Cobra_XxX
Hi,

man kann nicht in der gleichen Verbindung (transaction) Daten löschen und anschliessend ein VACCUM durchführen:

Code: 
Error details: cannot VACUUM from within a transaction

Entweder man macht es NACH dem "commit" oder besser in einer eigenen Verbindung wie vorgeschlagen.


like:

Python: 
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)
        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))
        conn.commit()

       # Datenbank um diese Einträge verkleinern
        conn.execute("VACUUM")
        conn.close()

oder

Python: 
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)
        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))
        conn.commit()
        conn.close()

        # Datenbank um diese Einträge verkleinern
        conn = sqlite3.connect(db_path)
        conn.execute("VACUUM")
        conn.close()
 
  • Like
Reaktionen: DaveR
Stimmt da hast du recht.

Also für alle die, die gesamten Skripts nochmal haben möchten:

Zur Info: Skripte sind getestet und funktionieren :)

Hier ist das Skript für die direkte Eingabe des Skriptes in der Aufgabe vom Aufgabenplaner:

Python: 
import subprocess
import sqlite3
from datetime import datetime, timedelta

# ANSI-Farbcodes für farbige Ausgaben
RED = '\033[0;31m'
BLUE = '\033[0;34m'
GREEN = '\033[0;32m'
NC = '\033[0m'  # ANSI-Code zum Zurücksetzen der Farbe

# Definiere Container und die Anzahl der Tage, die für jeden Container beibehalten werden sollen
CONTAINERS_DAYS = {
    "DynDNS": 31,
    # Weitere Container und deren Tage kannst du hier hinzufügen
}

# Standardanzahl an Tagen für alle anderen Container, die nicht in CONTAINERS_DAYS enthalten sind
DEFAULT_DAYS = 365

def get_all_containers():
    """Gibt eine Liste aller Container-Namen zurück."""
    result = subprocess.run(["docker", "ps", "-a", "--format", "{{.Names}}"], capture_output=True, text=True)
    return result.stdout.splitlines()

def get_log_path(container_name):
    """Gibt den Log-Pfad des Containers zurück."""
    result = subprocess.run(["docker", "inspect", "--format", "{{.LogPath}}", container_name], capture_output=True, text=True)
    return result.stdout.strip()

def cleanup_logs(db_path, days_to_keep, container_name):
    try:
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)

        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))

        conn.commit()
        conn.close()

        # Funktion zum verkleinern der Einträge in der DB ausführen
        vacuum_db(db_path)

        print(f"{GREEN}Finished:{NC} Log entries older than {days_to_keep} days have been cleaned up for the container {GREEN}'{container_name}'{NC} at: {db_path}.")
    except Exception as e:
        print(f"{RED}Warning:{NC} Log database file not found for container '{container_name}' at {db_path}")
        print(f"{RED}Error details:{NC} {e}")

def vacuum_db(db_path):
    try:
        conn = sqlite3.connect(db_path)

        # Datenbank um diese Einträge verkleinern
        conn.execute("VACUUM")
        conn.close()

    except Exception as e:
        print(f"{RED}Warning:{NC} Command 'VACUUM' in function 'vacuum_db' on db for container '{container_name}' at {db_path} failed.")
        print(f"{RED}Error details:{NC} {e}")
# Alle Container auflisten
containers = get_all_containers()

# Überprüfung auf nicht existierende Container in CONTAINERS_DAYS
for container_name in CONTAINERS_DAYS:
    if container_name not in containers:
        print(f"{RED}Warning:{NC} Container '{container_name}' doesn't exist. Please check container name...")

# Schleife über alle Container auf dem System
for container_name in containers:
    # Überprüfen, ob der Container spezielle Tage hat oder die Standardtage verwenden soll
    days_to_keep = CONTAINERS_DAYS.get(container_name, DEFAULT_DAYS)

    # Ermitteln des Log-DB-Pfads für den aktuellen Container
    log_path = get_log_path(container_name)

    if not log_path:
        print(f"{RED}Warning:{NC} No log file for container '{container_name}' found. Skipping container '{container_name}'...")
        continue

    cleanup_logs(log_path, days_to_keep, container_name)

und hier der Code für die eigene Skriptdatei:

Python: 
#!/bin/bash
python3 - <<END
import subprocess
import sqlite3
from datetime import datetime, timedelta

# ANSI-Farbcodes für farbige Ausgaben
RED = '\033[0;31m'
BLUE = '\033[0;34m'
GREEN = '\033[0;32m'
NC = '\033[0m'  # ANSI-Code zum Zurücksetzen der Farbe

# Definiere Container und die Anzahl der Tage, die für jeden Container beibehalten werden sollen
CONTAINERS_DAYS = {
    "DynDNS": 31,
    # Weitere Container und deren Tage kannst du hier hinzufügen
}

# Standardanzahl an Tagen für alle anderen Container, die nicht in CONTAINERS_DAYS enthalten sind
DEFAULT_DAYS = 365

def get_all_containers():
    """Gibt eine Liste aller Container-Namen zurück."""
    result = subprocess.run(["docker", "ps", "-a", "--format", "{{.Names}}"], capture_output=True, text=True)
    return result.stdout.splitlines()

def get_log_path(container_name):
    """Gibt den Log-Pfad des Containers zurück."""
    result = subprocess.run(["docker", "inspect", "--format", "{{.LogPath}}", container_name], capture_output=True, text=True)
    return result.stdout.strip()

def cleanup_logs(db_path, days_to_keep, container_name):
    try:
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()

        # Aktuelles Datum
        current_time = datetime.now()

        # Bereinigungsdatum berechnen
        cutoff_time = current_time - timedelta(days=days_to_keep)

        # SQL-Abfrage zum Löschen alter Einträge
        cursor.execute("DELETE FROM log WHERE created < ?", (cutoff_time.isoformat(),))

        conn.commit()
        conn.close()

        # Funktion zum verkleinern der Einträge in der DB ausführen
        vacuum_db(db_path)

        print(f"{GREEN}Finished:{NC} Log entries older than {days_to_keep} days have been cleaned up for the container {GREEN}'{container_name}'{NC} at: {db_path}.")
    except Exception as e:
        print(f"{RED}Warning:{NC} Log database file not found for container '{container_name}' at {db_path}")
        print(f"{RED}Error details:{NC} {e}")

def vacuum_db(db_path):
    try:
        conn = sqlite3.connect(db_path)

        # Datenbank um diese Einträge verkleinern
        conn.execute("VACUUM")
        conn.close()

    except Exception as e:
        print(f"{RED}Warning:{NC} Command 'VACUUM' in function 'vacuum_db' on db for container '{container_name}' at {db_path} failed.")
        print(f"{RED}Error details:{NC} {e}")
# Alle Container auflisten
containers = get_all_containers()

# Überprüfung auf nicht existierende Container in CONTAINERS_DAYS
for container_name in CONTAINERS_DAYS:
    if container_name not in containers:
        print(f"{RED}Warning:{NC} Container '{container_name}' doesn't exist. Please check container name...")

# Schleife über alle Container auf dem System
for container_name in containers:
    # Überprüfen, ob der Container spezielle Tage hat oder die Standardtage verwenden soll
    days_to_keep = CONTAINERS_DAYS.get(container_name, DEFAULT_DAYS)

    # Ermitteln des Log-DB-Pfads für den aktuellen Container
    log_path = get_log_path(container_name)

    if not log_path:
        print(f"{RED}Warning:{NC} No log file for container '{container_name}' found. Skipping container '{container_name}'...")
        continue

    cleanup_logs(log_path, days_to_keep, container_name)

END
 
  • Like
Reaktionen: DaveR und DrDeath


Schreibe deine Antwort....

Additional post fields

NAS-Central - Ihr Partner für NAS Lösungen
NAS-Central - The Home of NAS
 

Kaffeautomat

Wenn du das Forum hilfreich findest oder uns unterstützen möchtest, dann gib uns doch einfach einen Kaffee aus.

Als Dankeschön schalten wir deinen Account werbefrei.

:coffee:

Hier gehts zum Kaffeeautomat 

Hosted by netcup
IT Lösungen mit NAS Servern
IT Firma Trier
Fotograf Trier
   
Oben Unten