Comment arrêter l'affichage des messages INFO sur la console Spark?


189

Je voudrais arrêter divers messages qui arrivent sur Spark Shell.

J'ai essayé de modifier le log4j.propertiesfichier afin d'arrêter ces messages.

Voici le contenu de 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

Mais les messages sont toujours affichés sur la console.

Voici quelques exemples de messages

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

Comment les arrêter?

Réponses:


171

Modifiez votre conf/log4j.propertiesfichier et modifiez la ligne suivante:

log4j.rootCategory=INFO, console

à

log4j.rootCategory=ERROR, console

Une autre approche consisterait à:

Démarrez spark-shell et tapez ce qui suit:

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

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

Vous ne verrez aucun journal après cela.

D' autres options pour le niveau comprennent: all, debug, error, fatal, info, off, trace, trace_int,warn

Des détails sur chacun peuvent être trouvés dans la documentation.


15
Je pense que OFF est trop restrictif. WARN ou ERROR peut mieux convenir ici.
snowindy

2
Ajoutez cela dans la classe principale de vos projets.
AkhlD

2
Très bonne réponse. Un moyen de faire la même chose à partir de PySpark par programmation?
Tagar le

2
La partie programmatique de cela ne fonctionne pas. Au lieu de cela, voyez cette réponse de @cantdutchthis stackoverflow.com/a/37836847/1056563
javadba

1
Qui est ce @AkhlD?
Aviad Klein

161

Juste après le début du spark-shelltype;

sc.setLogLevel("ERROR")

Dans Spark 2.0 (Scala):

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

Documents de l'API: https://spark.apache.org/docs/2.2.0/api/scala/index.html#org.apache.spark.sql.SparkSession

Pour Java:

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

Comment définiriez-vous cette propriété dans un programme?
Alex Raj Kaliamoorthy

Ceci est uniquement disponible pour spark.sql.SparkSession ou également disponible pour JavaSparkContext ??
SharpLu

Oui, il est disponible pour JavaSparkContext . Merci, @cantdutchthis. Cela me dérange depuis un moment.
alan le

1
C'est la seule réponse qui a fonctionné pour moi sans créer un log4j séparé. Merci!
abhihello123

2
Cela fonctionne pour moi, mais je reçois encore quelques messages au début de mon test. Une idée?

47

Merci @AkhlD et @Sachin Janani pour avoir suggéré des changements dans le .conffichier.

Le code suivant a résolu mon problème:

1) Ajouté import org.apache.log4j.{Level, Logger}dans la section d'importation

2) Ajout de la ligne suivante après la création de l'objet de contexte Spark c'est à dire après val sc = new SparkContext(conf):

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

12
J'ai essayé cela mais j'ai toujours obtenu les sorties de journalisation.
horatio1701d

1
J'aime cette solution car je n'ai pas la permission d'accéder à conf /
Jim Ho

38

Toutes les méthodes recueillies avec des exemples

Intro

En fait, il existe de nombreuses façons de le faire . Certains sont plus difficiles par rapport aux autres, mais c'est à vous de décider lequel vous convient le mieux. Je vais essayer de tous les présenter.


# 1 par programme dans votre application

Cela semble être le plus simple, mais vous devrez recompiler votre application pour modifier ces paramètres. Personnellement, je n'aime pas ça mais ça marche bien.

Exemple:

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)

Vous pouvez réaliser bien plus simplement en utilisant l' log4jAPI.
Source: [ Docs de configuration Log4J , section Configuration]


# 2 Passe log4j.propertiespendantspark-submit

Celui-ci est très délicat, mais pas impossible. Et mon préféré.

Log4J au démarrage de l'application recherche et charge toujours le log4j.propertiesfichier à partir du chemin de classe.

Cependant, lorsque vous utilisez spark-submitle chemin de classe de Spark Cluster a la priorité sur le chemin de classe de l'application! C'est pourquoi mettre ce fichier dans votre fat-jar ne remplacera pas les paramètres du cluster!

Ajouter -Dlog4j.configuration=<location of configuration file>à spark.driver.extraJavaOptions (pour le pilote) ou
spark.executor.extraJavaOptions (pour les exécuteurs) .

Notez que si vous utilisez un fichier, le file:protocole doit être explicitement fourni et le fichier doit exister localement sur tous les nœuds .

Pour satisfaire la dernière condition, vous pouvez soit télécharger le fichier à l'emplacement disponible pour les nœuds (comme hdfs), soit y accéder localement avec le pilote si vous utilisez deploy-mode client. Autrement:

télécharger une personnalisation à l' log4j.propertiesaide de spark-submit, en l'ajoutant à la --filesliste des fichiers à télécharger avec l'application.

Source: documentation Spark, débogage

Pas:

Exemple 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

Exécution spark-submit, pour le mode cluster:

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"

Notez que vous devez utiliser --driver-java-optionssi vous utilisez clientmode. Documents Spark, environnement d'exécution

Exécution spark-submit, pour le mode client:

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"

Remarques:

  1. Les fichiers téléchargés vers spark-clusteravec --filesseront disponibles dans le répertoire racine, il n'est donc pas nécessaire d'ajouter un chemin dans file:log4j.properties.
  2. Les fichiers répertoriés dans --filesdoivent être fournis avec un chemin absolu!
  3. file: le préfixe dans l'URI de configuration est obligatoire.

# 3 Modifier les clusters conf/log4j.properties

Cela modifie le fichier de configuration de la journalisation globale .

mettez à jour le $SPARK_CONF_DIR/log4j.propertiesfichier et il sera automatiquement téléchargé avec les autres configurations.

Source: documentation Spark, débogage

Pour trouver votre, SPARK_CONF_DIRvous pouvez utiliser 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

Maintenant, modifiez simplement /var/lib/spark/latest/conf/log4j.properties(avec l'exemple de la méthode n ° 2) et toutes vos applications partageront cette configuration.


# 4 Remplacer le répertoire de configuration

Si vous aimez la solution n ° 3, mais que vous souhaitez la personnaliser par application, vous pouvez en fait copier le confdossier, en modifier le contenu et le spécifier comme configuration racine pendant spark-submit.

Pour spécifier un répertoire de configuration différent de celui par défaut “SPARK_HOME/conf”, vous pouvez définir SPARK_CONF_DIR. Spark utilisera les fichiers de configuration ( spark-defaults.conf, spark-env.sh, log4j.properties, etc. ) à partir de ce répertoire.

Source: documentation Spark, configuration

Pas:

  1. Copier le confdossier du cluster (plus d'informations, méthode n ° 3)
  2. Modifier log4j.propertiesdans ce dossier (exemple dans la méthode n ° 2)
  3. Définissez SPARK_CONF_DIRce dossier, avant d'exécuter spark-submit, par
    exemple:

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

Conclusion

Je ne sais pas s'il existe une autre méthode, mais j'espère que cela couvre le sujet de A à Z. Sinon, n'hésitez pas à me cingler dans les commentaires!

Profitez de votre chemin!


Cela devrait être la réponse acceptée. Il offre beaucoup de détails et résume bien plus de cas d'utilisation que les autres. (Sans encourager à désactiver les journaux.)
belgacea

@Atais - Vous devriez ajouter ci-dessous Donc, si vous êtes comme moi et trouvez que les réponses ci-dessus n'ont pas aidé, alors peut-être que vous devez aussi supprimer le suffixe '.template' de votre fichier de conf log4j et que ce qui précède fonctionne parfaitement!
6h17

1
Note supplémentaire sur l'approche programmatique - Le niveau doit être défini avant la création du SparkContext
Arunraj Nair

@ArunrajNair ne devrait pas être le cas, car la journalisation est une fonctionnalité distincte, non connectée à SparkContext.
Atais le

33

Utilisez la commande ci-dessous pour modifier le niveau de journal lors de la soumission de l'application à l'aide de spark-submit ou spark-sql:

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

Remarque: remplacez l' <file path>emplacement de log4jstockage du fichier de configuration.

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>

Basculez vers FileAppender dans log4j.xml si vous souhaitez écrire des journaux dans un fichier au lieu de la console. LOG_DIRest une variable pour le répertoire des journaux que vous pouvez fournir en utilisant 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>

Une autre chose importante à comprendre ici est que lorsque le travail est lancé en mode distribué (cluster en mode déploiement et maître en tant que fil ou mesos), le fichier de configuration log4j doit exister sur les nœuds pilote et worker ( log4j.configuration=file:<file path>/log4j.xml) sinon log4j init se plaindra-

log4j: ERREUR Impossible de lire le fichier de configuration [log4j.properties]. java.io.FileNotFoundException: log4j.properties (aucun fichier ou répertoire de ce type)

Astuce pour résoudre ce problème

Conservez le fichier de configuration log4j dans le système de fichiers distribué (HDFS ou mesos) et ajoutez une configuration externe à l'aide de log4j PropertyConfigurator . ou utilisez sparkContext addFile pour le rendre disponible sur chaque nœud, puis utilisez log4j PropertyConfigurator pour recharger la configuration.


2
C'est l'un des rares exemples qui ne supprime pas tous les orgjournaux qui proviennent traditionnellement de l'enregistreur par défaut.
deepelement

1
Cela fonctionne très bien, mais à quoi sert le Log4j.propertiesfichier? Cela ne semble pas être utilisé. Documentez-vous simplement les propriétés définies dans le fichier XML?
vy32

1
Vous pouvez utiliser l'un ou l'autre.
Rahul Sharma

3
J'ai eu du succès avec ce qui précède - j'utilise --filesdans la commande spark-submit pour rendre log4j.properties disponible sur tous les nœuds.
Ben Watson

1
C'est la seule solution qui a fonctionné pour moi et elle n'implique aucun changement de code. Créez un fichier Log4.propertiessous main/resourcesau cas où il n'existerait pas
Yeikel

19

Vous définissez désactiver les journaux en définissant son niveau sur OFF comme suit:

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

ou modifiez le fichier journal et désactivez le niveau de journalisation en modifiant simplement la propriété suivante:

log4j.rootCategory=OFF, console

Dans quel fichier dois-je définir les propriétés ci-dessus?
Vishwas le

Vous pouvez ajouter ces lignes dans votre programme Driver @Vishwas
Sachin Janani

J'ai ajouté la même chose mais les journaux apparaissent toujours sur la console
Vishwas

Avez-vous modifié la propriété log4j.rootCategory = OFF. Je les ai testés à ma fin et cela fonctionne bien
Sachin Janani

3
Cela ne fait aucune différence pour moi sur Spark 2.3.1
Toby Eggitt

15

J'ajoute simplement cette ligne à tous mes scripts pyspark en haut juste en dessous des instructions d'importation.

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

exemple d'en-tête de mes scripts pyspark

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

14
Cela fonctionne, mais cela n'arrête pas les 58 lignes de messages INFO qui apparaissent lors de la création du contexte Spark.
vy32

1
Notez que ceci est pour Spark 2.x
Yeikel

13

Les réponses ci-dessus sont correctes mais ne m'ont pas vraiment aidé car j'avais besoin d'informations supplémentaires.

Je viens de configurer Spark pour que le fichier log4j ait toujours le suffixe «.template» et ne soit pas lu. Je crois que la journalisation est ensuite définie par défaut sur Spark core logging conf.

Donc, si vous êtes comme moi et trouvez que les réponses ci-dessus n'ont pas aidé, alors peut-être que vous devez aussi supprimer le suffixe '.template' de votre fichier de configuration log4j et que ce qui précède fonctionne parfaitement!

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


Veuillez vérifier cette réponse, stackoverflow.com/a/51554118/2094086, j'espère que vous recherchez la même chose.
Gaurav Adurkar

5

En Python / Spark, nous pouvons faire:

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 )

Après avoir défini Sparkcontaxt 'sc', appelez cette fonction par: quiet_logs (sc)


J'adorerais trouver un moyen de programmation qui fonctionne sans jouer avec le fichier log4j - mais quand j'essaie, je reçois toujours des avertissements comme WARN org.apache.spark.scheduler.TaskSetManager: tâche perdue 612.1 à l'étape 0.0 (TID 2570 ..., exécuteur testamentaire 15): TaskKilled (un autre
attem

5

tl; dr

Pour Spark Context, vous pouvez utiliser:

sc.setLogLevel(<logLevel>)

loglevelpeut être ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE ou WARN.


Détails-

En interne, setLogLevelappels org.apache.log4j.Level.toLevel(logLevel)qu'il utilise ensuite pour définir en utilisant org.apache.log4j.LogManager.getRootLogger().setLevel(level).

Vous pouvez directement définir les niveaux de journalisation en OFFutilisant:

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

Vous pouvez configurer la journalisation par défaut pour Spark Shell dans conf/log4j.properties. Utilisez conf/log4j.properties.templatecomme point de départ.

Définition des niveaux de journal dans les applications Spark

Dans les applications Spark autonomes ou pendant la session Spark Shell, utilisez ce qui suit:

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

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

Désactivation de la journalisation (dans log4j):

Utilisez ce qui suit conf/log4j.propertiespour désactiver complètement la journalisation:

log4j.logger.org=OFF

Référence: Mastering Spark par Jacek Laskowski.


4

Ajoutez simplement le paramètre ci-dessous à votre commande spark-shell OU spark-submit

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

Vérifiez le nom exact de la propriété (log4jspark.root.logger ici) dans le fichier log4j.properties. J'espère que cela aide, bravo!


1
Définir cela à partir de la ligne de commande aurait été génial. Mais cela n'a pas fonctionné pour moi.
swdev

3

Simple à faire sur la ligne de commande ...

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


qu'est ce que c'est spark2-submit?
vy32

spark2-submit est utilisé pour Spark2.
Nephilim

2

Une idée intéressante est d'utiliser le RollingAppender comme suggéré ici: http://shzhangji.com/blog/2015/05/31/spark-streaming-logging-configuration/ afin de ne pas «poluer» l'espace de la console, mais toujours être en mesure de voir les résultats sous $ YOUR_LOG_PATH_HERE / $ {dm.logging.name} .log.

    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

Une autre méthode qui résout la cause est d'observer le type de journalisation que vous avez habituellement (provenant de différents modules et dépendances), et de définir pour chacun la granularité de la journalisation, tout en transformant les journaux tiers "silencieux" qui sont trop détaillés:

Par exemple,

    # 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

0
  1. Ajustez conf / log4j.properties comme décrit par d'autres log4j.rootCategory = ERROR, console
  2. Assurez-vous lors de l'exécution de votre tâche Spark que vous transmettez l'indicateur --file avec le chemin du fichier log4j.properties
  3. Si cela ne fonctionne toujours pas, vous pouvez avoir un fichier jar contenant log4j.properties qui est appelé avant votre nouveau log4j.properties. Supprimez ce log4j.properties du fichier jar (le cas échéant)

0
sparkContext.setLogLevel("OFF")

1
J'ai fait les deux - supprimé le suffixe .template de log4j.properties et défini le niveau sur ERROR, et val rootLogger = Logger.getRootLogger() rootLogger.setLevel(Level.ERROR) cela a fonctionné
Sam-T

0

En plus de tous les articles ci-dessus, voici ce qui a résolu le problème pour moi.

Spark utilise slf4j pour se lier aux enregistreurs. Si log4j n'est pas la première liaison trouvée, vous pouvez éditer les fichiers log4j.properties autant que vous le souhaitez, les enregistreurs ne sont même pas utilisés. Par exemple, cela pourrait être une sortie SLF4J possible:

SLF4J: le chemin de classe contient plusieurs liaisons SLF4J. SLF4J: liaison trouvée dans [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: liaison trouvée dans [jar: file: / C: /Users/~/.m2/repository/org/slf4j/slf4j-log4j12/1.7.19/slf4j-log4j12-1.7.19.jar ! /org/slf4j/impl/StaticLoggerBinder.class] SLF4J: Voir http://www.slf4j.org/codes.html#multiple_bindings pour une explication. SLF4J: la liaison réelle est de type [org.slf4j.impl.SimpleLoggerFactory]

Donc, ici, SimpleLoggerFactory a été utilisé, qui ne se soucie pas des paramètres de log4j.

Exclure le package slf4j-simple de mon projet via

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

a résolu le problème, car maintenant la liaison de journalisation log4j est utilisée et tout paramètre de log4j.properties est respecté. FYI mon fichier de propriétés log4j contient (en plus de la configuration normale)

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

J'espère que cela t'aides!


0

Celui-ci a fonctionné pour moi. Pour que seuls les messages d'ERREUR soient affichés comme stdout, le log4j.propertiesfichier peut ressembler à:

# 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

REMARQUE: placez le log4j.propertiesfichier dans le src/main/resourcesdossier pour être efficace. Et si log4j.propertiesn'existe pas (sens sparkutilise le log4j-defaults.propertiesfichier), vous pouvez créer en allant SPARK_HOME/confet mv log4j.properties.template log4j.propertiespuis procéder à des changements au- dessus dudit.


0

Si vous n'avez pas la possibilité de modifier le code java pour insérer les .setLogLevel()instructions et que vous ne voulez pas encore déployer plus de fichiers externes, vous pouvez utiliser un moyen de force brute pour résoudre ce problème. Filtrez simplement les lignes INFO en utilisant grep.

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

0

Si quelqu'un d'autre est coincé là-dessus,

rien de ce qui précède n'a fonctionné pour moi. Je devais supprimer

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'

de mon build.gradle pour que les journaux disparaissent. TLDR: N'importez aucun autre framework de journalisation, vous devriez être bien en utilisantorg.apache.log4j.Logger


0

Une autre façon d'arrêter complètement les journaux est:

    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...}

        }
    }

Cela a fonctionné pour moi. Un NullAppender est

Un Appender qui ignore les événements du journal. ( https://logging.apache.org/log4j/2.x/log4j-core/apidocs/org/apache/logging/log4j/core/appender/NullAppender.html )

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.