Ich möchte verschiedene Nachrichten stoppen, die auf Spark Shell kommen.

Ich habe versucht, die log4j.propertiesDatei zu bearbeiten , um diese Nachricht zu stoppen.

Hier sind die Inhalte von log4j.properties

# Define the root logger with appender file
log4j.rootCategory=WARN, console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n

# Settings to quiet third party logs that are too verbose
log4j.logger.org.eclipse.jetty=WARN
log4j.logger.org.eclipse.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=INFO
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=INFO

Es werden jedoch weiterhin Nachrichten auf der Konsole angezeigt.

Hier sind einige Beispielnachrichten

15/01/05 15:11:45 INFO SparkEnv: Registering BlockManagerMaster
15/01/05 15:11:45 INFO DiskBlockManager: Created local directory at /tmp/spark-local-20150105151145-b1ba
15/01/05 15:11:45 INFO MemoryStore: MemoryStore started with capacity 0.0 B.
15/01/05 15:11:45 INFO ConnectionManager: Bound socket to port 44728 with id = ConnectionManagerId(192.168.100.85,44728)
15/01/05 15:11:45 INFO BlockManagerMaster: Trying to register BlockManager
15/01/05 15:11:45 INFO BlockManagerMasterActor$BlockManagerInfo: Registering block manager 192.168.100.85:44728 with 0.0 B RAM
15/01/05 15:11:45 INFO BlockManagerMaster: Registered BlockManager
15/01/05 15:11:45 INFO HttpServer: Starting HTTP Server
15/01/05 15:11:45 INFO HttpBroadcast: Broadcast server star

Wie stoppe ich diese?

Bearbeiten Sie Ihre conf/log4j.propertiesDatei und ändern Sie die folgende Zeile:

log4j.rootCategory=INFO, console

zu

log4j.rootCategory=ERROR, console

Ein anderer Ansatz wäre:

Starten Sie die Funkenschale und geben Sie Folgendes ein:

import org.apache.log4j.Logger
import org.apache.log4j.Level

Logger.getLogger("org").setLevel(Level.OFF)
Logger.getLogger("akka").setLevel(Level.OFF)

Danach werden keine Protokolle mehr angezeigt.

Weitere Optionen für Stufen sind: all, debug, error, fatal, info, off, trace, trace_int,warn

Details dazu finden Sie in der Dokumentation.

Gleich nach dem Start spark-shellTyp;

sc.setLogLevel("ERROR")

In Spark 2.0 (Scala):

spark = SparkSession.builder.getOrCreate()
spark.sparkContext.setLogLevel("ERROR")

API-Dokumente: https://spark.apache.org/docs/2.2.0/api/scala/index.html#org.apache.spark.sql.SparkSession

Für Java:

spark = SparkSession.builder.getOrCreate();
spark.sparkContext().setLogLevel("ERROR");

Vielen Dank an @AkhlD und @Sachin Janani, dass sie Änderungen in der .confDatei vorgeschlagen haben.

Der folgende Code hat mein Problem gelöst:

1) import org.apache.log4j.{Level, Logger}Im Importbereich hinzugefügt

2) Folgende Zeile nach dem Erstellen des Spark-Kontextobjekts hinzugefügt, dh nach val sc = new SparkContext(conf):

val rootLogger = Logger.getRootLogger()
rootLogger.setLevel(Level.ERROR)

Verwenden Sie den folgenden Befehl, um die Protokollstufe zu ändern, während Sie die Anwendung mit spark-submit oder spark-sql senden:

spark-submit \
--conf "spark.driver.extraJavaOptions=-Dlog4j.configuration=file:<file path>/log4j.xml" \
--conf "spark.executor.extraJavaOptions=-Dlog4j.configuration=file:<file path>/log4j.xml"

Hinweis: Ersetzen Sie, <file path>wo die log4jKonfigurationsdatei gespeichert ist.

Log4j.properties:

log4j.rootLogger=ERROR, console

# set the log level for these components
log4j.logger.com.test=DEBUG
log4j.logger.org=ERROR
log4j.logger.org.apache.spark=ERROR
log4j.logger.org.spark-project=ERROR
log4j.logger.org.apache.hadoop=ERROR
log4j.logger.io.netty=ERROR
log4j.logger.org.apache.zookeeper=ERROR

# add a ConsoleAppender to the logger stdout to write to the console
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.layout=org.apache.log4j.PatternLayout
# use a simple message format
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

log4j.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
   <appender name="console" class="org.apache.log4j.ConsoleAppender">
    <param name="Target" value="System.out"/>
    <layout class="org.apache.log4j.PatternLayout">
    <param name="ConversionPattern" value="%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n" />
    </layout>
  </appender>
    <logger name="org.apache.spark">
        <level value="error" />
    </logger>
    <logger name="org.spark-project">
        <level value="error" />
    </logger>
    <logger name="org.apache.hadoop">
        <level value="error" />
    </logger>
    <logger name="io.netty">
        <level value="error" />
    </logger>
    <logger name="org.apache.zookeeper">
        <level value="error" />
    </logger>
   <logger name="org">
        <level value="error" />
    </logger>
    <root>
        <priority value ="ERROR" />
        <appender-ref ref="console" />
    </root>
</log4j:configuration>

Wechseln Sie in log4j.xml zu FileAppender, wenn Sie Protokolle anstelle der Konsole in eine Datei schreiben möchten. LOG_DIRist eine Variable für das Protokollverzeichnis, mit der Sie angeben können spark-submit --conf "spark.driver.extraJavaOptions=-D.

<appender name="file" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="${LOG_DIR}"/>
        <param name="datePattern" value="'.'yyyy-MM-dd"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%d [%t] %-5p %c %x - %m%n"/>
        </layout>
    </appender>

Eine weitere wichtige Sache, die Sie hier verstehen sollten, ist, dass beim Starten des Jobs im verteilten Modus (Cluster im Bereitstellungsmodus und Master als Garn oder Mesos) die log4j-Konfigurationsdatei auf Treiber- und Arbeiterknoten ( log4j.configuration=file:<file path>/log4j.xml) vorhanden sein sollte, da sich sonst log4j init beschwert.

log4j: FEHLER Konfigurationsdatei [log4j.properties] konnte nicht gelesen werden. java.io.FileNotFoundException: log4j.properties (Keine solche Datei oder kein solches Verzeichnis)

Hinweis zur Lösung dieses Problems-

Behalten Sie die log4j-Konfigurationsdatei im verteilten Dateisystem (HDFS oder Mesos) bei und fügen Sie mithilfe des log4j PropertyConfigurator eine externe Konfiguration hinzu . Oder verwenden Sie sparkContext addFile , um es auf jedem Knoten verfügbar zu machen, und verwenden Sie dann log4j PropertyConfigurator, um die Konfiguration neu zu laden.

Alle Methoden mit Beispielen gesammelt

Intro

Tatsächlich gibt es viele Möglichkeiten, dies zu tun . Einige sind schwerer als andere, aber es liegt an Ihnen, welches am besten zu Ihnen passt. Ich werde versuchen, sie alle zu präsentieren.

# 1 Programmatisch in Ihrer App

Scheint am einfachsten zu sein, aber Sie müssen Ihre App neu kompilieren, um diese Einstellungen zu ändern. Persönlich mag ich es nicht, aber es funktioniert gut.

Beispiel:

import org.apache.log4j.{Level, Logger}

val rootLogger = Logger.getRootLogger()
rootLogger.setLevel(Level.ERROR)

Logger.getLogger("org.apache.spark").setLevel(Level.WARN)
Logger.getLogger("org.spark-project").setLevel(Level.WARN)

Mit der log4jAPI können Sie viel mehr erreichen .
Quelle: [ Log4J-Konfigurationsdokumente , Konfigurationsabschnitt]

# 2 Pass log4j.propertieswährendspark-submit

Dieser ist sehr knifflig, aber nicht unmöglich. Und mein Favorit.

Log4J sucht und lädt beim Starten der App immer eine log4j.propertiesDatei aus dem Klassenpfad.

Bei Verwendung von spark-submitSpark Cluster hat der Klassenpfad jedoch Vorrang vor dem Klassenpfad der App! Aus diesem Grund überschreibt das Einfügen dieser Datei in Ihr Fat-Jar die Einstellungen des Clusters nicht!

Hinzufügen -Dlog4j.configuration=<location of configuration file>zu spark.driver.extraJavaOptions (für den Treiber) oder
spark.executor.extraJavaOptions (für Ausführende) .

Beachten Sie, dass bei Verwendung einer Datei das file:Protokoll explizit angegeben werden sollte und die Datei lokal auf allen Knoten vorhanden sein muss .

Um die letzte Bedingung zu erfüllen, können Sie die Datei entweder an den für die Knoten verfügbaren Speicherort (wie hdfs) hochladen oder bei Verwendung lokal mit dem Treiber darauf zugreifen deploy-mode client. Andernfalls:

Laden Sie eine benutzerdefinierte Datei log4j.propertiesmit spark-submit hoch, indem Sie sie zur --filesListe der Dateien hinzufügen, die mit der Anwendung hochgeladen werden sollen.

Quelle: Spark-Dokumente, Debugging

Schritte:

Beispiel log4j.properties:

# Blacklist all to warn level
log4j.rootCategory=WARN, console

log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.target=System.err
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yy/MM/dd HH:mm:ss} %p %c{1}: %m%n

# Whitelist our app to info :)
log4j.logger.com.github.atais=INFO

Ausführen spark-submitfür den Cluster-Modus:

spark-submit \
    --master yarn \
    --deploy-mode cluster \
    --conf "spark.driver.extraJavaOptions=-Dlog4j.configuration=file:log4j.properties" \
    --conf "spark.executor.extraJavaOptions=-Dlog4j.configuration=file:log4j.properties" \
    --files "/absolute/path/to/your/log4j.properties" \
    --class com.github.atais.Main \
    "SparkApp.jar"

Beachten Sie, dass Sie verwenden müssen, --driver-java-optionswenn Sie den clientModus verwenden. Spark-Dokumente, Runtime env

Ausführen spark-submitfür den Client-Modus:

spark-submit \
    --master yarn \
    --deploy-mode client \
    --driver-java-options "-Dlog4j.configuration=file:/absolute/path/to/your/log4j.properties \
    --conf "spark.executor.extraJavaOptions=-Dlog4j.configuration=file:log4j.properties" \
    --files "/absolute/path/to/your/log4j.properties" \
    --class com.github.atais.Main \
    "SparkApp.jar"

Anmerkungen:

1. Dateien, die spark-clustermit hochgeladen wurden, --filessind im Stammverzeichnis verfügbar, sodass kein Pfad hinzugefügt werden muss file:log4j.properties.
2. Die in aufgeführten Dateien --filesmüssen mit einem absoluten Pfad versehen sein!
3. file: Das Präfix im Konfigurations-URI ist obligatorisch.

# 3 Cluster bearbeiten conf/log4j.properties

Dadurch wird die Konfigurationsdatei für die globale Protokollierung geändert .

Aktualisieren Sie die $SPARK_CONF_DIR/log4j.propertiesDatei und sie wird automatisch zusammen mit den anderen Konfigurationen hochgeladen.

Quelle: Spark-Dokumente, Debugging

Um Ihre zu finden, können SPARK_CONF_DIRSie verwenden spark-shell:

atais@cluster:~$ spark-shell 
Welcome to
      ____              __
     / __/__  ___ _____/ /__
    _\ \/ _ \/ _ `/ __/  '_/
   /___/ .__/\_,_/_/ /_/\_\   version 2.1.1
      /_/   

scala> System.getenv("SPARK_CONF_DIR")
res0: String = /var/lib/spark/latest/conf

Bearbeiten Sie jetzt einfach /var/lib/spark/latest/conf/log4j.properties(mit Beispiel aus Methode 2) und alle Ihre Apps teilen diese Konfiguration.

# 4 Konfigurationsverzeichnis überschreiben

Wenn Ihnen die Lösung Nr. 3 gefällt, Sie sie jedoch pro Anwendung anpassen möchten, können Sie den confOrdner tatsächlich kopieren , den Inhalt bearbeiten und währenddessen die Stammkonfiguration angeben spark-submit.

Um ein anderes als das Standardkonfigurationsverzeichnis anzugeben “SPARK_HOME/conf”, können Sie festlegen SPARK_CONF_DIR. Spark verwenden , um die Konfigurationsdateien ( spark-defaults.conf, spark-env.sh, log4j.properties, usw. ) aus diesem Verzeichnis.

Quelle: Spark-Dokumente, Konfiguration

Schritte:

1. Kopieren Sie den confOrdner des Clusters (weitere Informationen, Methode 3).
2. log4j.propertiesIn diesem Ordner bearbeiten (Beispiel in Methode 2)

3. Stellen Sie SPARK_CONF_DIRin diesem Ordner, vor der Ausführung spark-submit,
   zB:

   export SPARK_CONF_DIR=/absolute/path/to/custom/conf
   
   spark-submit \
       --master yarn \
       --deploy-mode cluster \
       --class com.github.atais.Main \
       "SparkApp.jar"
   

Fazit

Ich bin mir nicht sicher, ob es eine andere Methode gibt, aber ich hoffe, dass dies das Thema von A bis Z abdeckt. Wenn nicht, können Sie mich gerne in den Kommentaren anpingen!

Genieße deinen Weg!

Sie deaktivieren die Protokolle, indem Sie den Pegel wie folgt auf AUS setzen:

Logger.getLogger("org").setLevel(Level.OFF);
Logger.getLogger("akka").setLevel(Level.OFF);

oder bearbeiten Sie die Protokolldatei und setzen Sie die Protokollstufe auf Aus, indem Sie einfach die folgende Eigenschaft ändern:

log4j.rootCategory=OFF, console

Ich füge diese Zeile einfach allen meinen Pyspark-Skripten oben direkt unter den Importanweisungen hinzu.

SparkSession.builder.getOrCreate().sparkContext.setLogLevel("ERROR")

Beispiel-Header meiner Pyspark-Skripte

from pyspark.sql import SparkSession, functions as fs
SparkSession.builder.getOrCreate().sparkContext.setLogLevel("ERROR")

Die obigen Antworten sind korrekt, haben mir aber nicht gerade geholfen, da ich zusätzliche Informationen benötigte.

Ich habe gerade Spark eingerichtet, sodass die log4j-Datei immer noch das Suffix '.template' hatte und nicht gelesen wurde. Ich glaube, dass die Protokollierung dann standardmäßig Spark Core Logging Conf ist.

Wenn Sie also wie ich sind und feststellen, dass die obigen Antworten nicht geholfen haben, müssen Sie möglicherweise auch das Suffix '.template' aus Ihrer log4j conf-Datei entfernen, und dann funktioniert das oben Gesagte einwandfrei!

http://apache-spark-user-list.1001560.n3.nabble.com/disable-log4j-for-spark-shell-td11278.html

In Python / Spark können wir:

def quiet_logs( sc ):
  logger = sc._jvm.org.apache.log4j
  logger.LogManager.getLogger("org"). setLevel( logger.Level.ERROR )
  logger.LogManager.getLogger("akka").setLevel( logger.Level.ERROR )

Die nach der Definition von Sparkcontaxt 'sc' rufen diese Funktion auf von: quiet_logs (sc)

tl; dr

Für den Spark-Kontext können Sie Folgendes verwenden:

sc.setLogLevel(<logLevel>)

Wo loglevelkann ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE oder WARN sein.

Einzelheiten-

Intern werden setLogLevelAufrufe verwendet org.apache.log4j.Level.toLevel(logLevel), die dann zum Festlegen von using verwendet werden org.apache.log4j.LogManager.getRootLogger().setLevel(level).

Sie können die Protokollierungsstufen direkt auf Folgendes einstellen OFF:

LogManager.getLogger("org").setLevel(Level.OFF)

Sie können die Standardprotokollierung für die Spark-Shell einrichten conf/log4j.properties. Verwenden Sie conf/log4j.properties.templateals Ausgangspunkt.

Festlegen von Protokollebenen in Spark-Anwendungen

Verwenden Sie in eigenständigen Spark-Anwendungen oder während einer Spark Shell-Sitzung Folgendes:

import org.apache.log4j.{Level, Logger}

Logger.getLogger(classOf[RackResolver]).getLevel
Logger.getLogger("org").setLevel(Level.OFF)
Logger.getLogger("akka").setLevel(Level.OFF)

Deaktivieren der Protokollierung (in log4j):

Verwenden Sie Folgendes conf/log4j.properties, um die Protokollierung vollständig zu deaktivieren:

log4j.logger.org=OFF

Referenz: Mastering Spark von Jacek Laskowski.

Fügen Sie einfach den folgenden Parameter zu Ihrem Spark-Shell- ODER Spark-Submit-Befehl hinzu

--conf "spark.driver.extraJavaOptions=-Dlog4jspark.root.logger=WARN,console"

Überprüfen Sie den genauen Eigenschaftsnamen (log4jspark.root.logger hier) aus der Datei log4j.properties. Hoffe das hilft, Prost!

Eine interessante Idee ist es, den RollingAppender wie hier vorgeschlagen zu verwenden: http://shzhangji.com/blog/2015/05/31/spark-streaming-logging-configuration/, damit Sie den Konsolenbereich nicht "verschmutzen", sondern Die Ergebnisse können weiterhin unter $ YOUR_LOG_PATH_HERE / $ {dm.logging.name} .log angezeigt werden.

    log4j.rootLogger=INFO, rolling

log4j.appender.rolling=org.apache.log4j.RollingFileAppender
log4j.appender.rolling.layout=org.apache.log4j.PatternLayout
log4j.appender.rolling.layout.conversionPattern=[%d] %p %m (%c)%n
log4j.appender.rolling.maxFileSize=50MB
log4j.appender.rolling.maxBackupIndex=5
log4j.appender.rolling.file=$YOUR_LOG_PATH_HERE/${dm.logging.name}.log
log4j.appender.rolling.encoding=UTF-8

Eine andere Methode, die die Ursache behebt, besteht darin, zu beobachten, welche Art von Protokollierungen Sie normalerweise haben (die aus verschiedenen Modulen und Abhängigkeiten stammen), und für jede die Granularität für die Protokollierung festzulegen, während Sie "leise" Protokolle von Drittanbietern erstellen, die zu ausführlich sind:

Zum Beispiel,

    # Silence akka remoting
log4j.logger.Remoting=ERROR
log4j.logger.akka.event.slf4j=ERROR
log4j.logger.org.spark-project.jetty.server=ERROR
log4j.logger.org.apache.spark=ERROR
log4j.logger.com.anjuke.dm=${dm.logging.level}
log4j.logger.org.eclipse.jetty=WARN
log4j.logger.org.eclipse.jetty.util.component.AbstractLifeCycle=ERROR
log4j.logger.org.apache.spark.repl.SparkIMain$exprTyper=INFO
log4j.logger.org.apache.spark.repl.SparkILoop$SparkILoopInterpreter=INFO

Einfach in der Kommandozeile zu machen ...

spark2-submit --driver-java-options="-Droot.logger=ERROR,console" ..andere Optionen..

1. Passen Sie conf / log4j.properties wie von anderer log4j.rootCategory = ERROR, Konsole beschrieben an
2. Stellen Sie sicher, dass Sie beim Ausführen Ihres Spark-Jobs das Flag --file mit dem Dateipfad log4j.properties übergeben
3. Wenn es immer noch nicht funktioniert, haben Sie möglicherweise ein JAR mit log4j.properties, das vor Ihren neuen log4j.properties aufgerufen wird. Entfernen Sie diese log4j.properties aus dem Glas (falls zutreffend).

sparkContext.setLogLevel("OFF")

Zusätzlich zu all den oben genannten Beiträgen hat hier das Problem für mich gelöst.

Spark verwendet slf4j, um sich an Logger zu binden. Wenn log4j nicht die erste gefundene Bindung ist, können Sie die Dateien log4j.properties nach Belieben bearbeiten. Die Logger werden nicht einmal verwendet. Dies könnte beispielsweise eine mögliche SLF4J-Ausgabe sein:

SLF4J: Der Klassenpfad enthält mehrere SLF4J-Bindungen. SLF4J: Bindung gefunden in [jar: file: / C: /Users/~/.m2/repository/org/slf4j/slf4j-simple/1.6.6/slf4j-simple-1.6.6.jar! / Org / slf4j / impl / StaticLoggerBinder.class] SLF4J: Bindung in [jar: file: / C: /Users/~/.m2/repository/org/slf4j/slf4j-log4j12/1.7.19/slf4j-log4j12-1.7.19.jar gefunden ! /org/slf4j/impl/StaticLoggerBinder.class] SLF4J: Eine Erklärung finden Sie unter http://www.slf4j.org/codes.html#multiple_bindings . SLF4J: Die tatsächliche Bindung ist vom Typ [org.slf4j.impl.SimpleLoggerFactory]

Hier wurde also die SimpleLoggerFactory verwendet, die sich nicht um die log4j-Einstellungen kümmert.

Ausschluss des slf4j-simple Pakets aus meinem Projekt über

<dependency>
        ...
        <exclusions>
            ...
            <exclusion>
                <artifactId>slf4j-simple</artifactId>
                <groupId>org.slf4j</groupId>
            </exclusion>
        </exclusions>
    </dependency>

Das Problem wurde behoben, da jetzt die log4j-Logger-Bindung verwendet wird und alle Einstellungen in log4j.properties eingehalten werden. Zu Ihrer Information, meine log4j-Eigenschaftendatei enthält (neben der normalen Konfiguration)

log4j.rootLogger=WARN, stdout
...
log4j.category.org.apache.spark = WARN
log4j.category.org.apache.parquet.hadoop.ParquetRecordReader = FATAL
log4j.additivity.org.apache.parquet.hadoop.ParquetRecordReader=false
log4j.logger.org.apache.parquet.hadoop.ParquetRecordReader=OFF

Hoffe das hilft!

Dieser hat für mich gearbeitet. Damit nur FEHLER-Meldungen als angezeigt werden stdout, log4j.propertiessieht die Datei möglicherweise folgendermaßen aus:

# Root logger option
log4j.rootLogger=ERROR, stdout
# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

HINWEIS: Legen Sie die log4j.propertiesDatei in einem src/main/resourcesOrdner ab, damit sie wirksam wird. Und wenn log4j.propertieses keine gibt (was bedeutet spark, dass eine log4j-defaults.propertiesDatei verwendet wird), können Sie sie erstellen, indem Sie zu SPARK_HOME/confund dann gehen mv log4j.properties.template log4j.propertiesund dann mit den oben genannten Änderungen fortfahren.

Wenn Sie nicht in der Lage sind, den Java-Code zum Einfügen der .setLogLevel()Anweisungen zu bearbeiten und noch keine weiteren externen Dateien bereitstellen möchten, können Sie dies mithilfe einer Brute-Force-Methode lösen. Filtern Sie einfach die INFO-Zeilen mit grep heraus.

spark-submit --deploy-mode client --master local <rest-of-cmd> | grep -v -F "INFO"

Wenn jemand anderes daran festhält,

Nichts davon hat bei mir funktioniert. Ich musste entfernen

implementation group: "ch.qos.logback", name: "logback-classic", version: "1.2.3"
implementation group: 'com.typesafe.scala-logging', name: "scala-logging_$scalaVersion", version: '3.9.2'

von meinem build.gradle, damit die Protokolle verschwinden. TLDR: Importieren Sie keine anderen Protokollierungsframeworks. Sie sollten nur diese verwendenorg.apache.log4j.Logger

Eine andere Möglichkeit, Protokolle vollständig zu stoppen, ist:

    import org.apache.log4j.Appender;
    import org.apache.log4j.BasicConfigurator;
    import org.apache.log4j.varia.NullAppender;

    public class SomeClass {

        public static void main(String[] args) {
            Appender nullAppender = new NullAppender();
            BasicConfigurator.configure(nullAppender);

            {...more code here...}

        }
    }

Das hat bei mir funktioniert. Ein NullAppender ist

Ein Appender, der Protokollereignisse ignoriert. ( https://logging.apache.org/log4j/2.x/log4j-core/apidocs/org/apache/logging/log4j/core/appender/NullAppender.html )