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?

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.

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");

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)

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!

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.

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

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")

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

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)

tl; dr

Pour Spark Context, vous pouvez utiliser:

sc.setLogLevel(<logLevel>)

où 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.

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!

Simple à faire sur la ligne de commande ...

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

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

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)

sparkContext.setLogLevel("OFF")

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!

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.

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"

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

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 )