Me gustaría detener varios mensajes que llegan en spark shell.

Traté de editar el log4j.propertiesarchivo para detener este mensaje.

Aquí están los contenidos 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

Pero los mensajes todavía se muestran en la consola.

Aquí hay algunos mensajes de ejemplo

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

¿Cómo detengo esto?

Edite su conf/log4j.propertiesarchivo y cambie la siguiente línea:

log4j.rootCategory=INFO, console

a

log4j.rootCategory=ERROR, console

Otro enfoque sería:

Inicie spark-shell y escriba lo siguiente:

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

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

No verá ningún registro después de eso.

Otras opciones para el Nivel incluyen: all, debug, error, fatal, info, off, trace, trace_int,warn

Los detalles sobre cada uno se pueden encontrar en la documentación.

Justo después de comenzar el spark-shelltipo;

sc.setLogLevel("ERROR")

En Spark 2.0 (Scala):

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

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

Para Java:

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

Gracias @AkhlD y @Sachin Janani por sugerir cambios en el .confarchivo.

El siguiente código resolvió mi problema:

1) Agregado import org.apache.log4j.{Level, Logger}en la sección de importación

2) Se agregó la siguiente línea después de la creación del objeto de contexto de chispa, es decir, después de val sc = new SparkContext(conf):

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

Use el siguiente comando para cambiar el nivel de registro al enviar la aplicación usando spark-submit o 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"

Nota: reemplace <file path>donde log4jse almacena el archivo de configuración.

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>

Cambie a FileAppender en log4j.xml si desea escribir registros en el archivo en lugar de la consola. LOG_DIRes una variable para el directorio de registros que puede proporcionar utilizando 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>

Otra cosa importante a entender aquí es que, cuando el trabajo se inicia en modo distribuido (clúster de despliegue en modo y maestro como hilo o mesos), el archivo de configuración log4j debe existir en los nodos de controlador y de trabajo ( log4j.configuration=file:<file path>/log4j.xml) de lo contrario log4j init se quejará.

log4j: ERROR No se pudo leer el archivo de configuración [log4j.properties]. java.io.FileNotFoundException: log4j.properties (No existe tal archivo o directorio)

Sugerencia para resolver este problema

Mantenga el archivo de configuración log4j en el sistema de archivos distribuido (HDFS o mesos) y agregue la configuración externa utilizando Log4j PropertyConfigurator . o use sparkContext addFile para que esté disponible en cada nodo y luego use log4j PropertyConfigurator para recargar la configuración.

Todos los métodos recopilados con ejemplos.

Introducción

En realidad, hay muchas formas de hacerlo . Algunos son más difíciles de otros, pero depende de usted cuál le conviene más. Trataré de mostrarlos a todos.

# 1 de forma programática en su aplicación

Parece ser la más fácil, pero deberá volver a compilar su aplicación para cambiar esa configuración. Personalmente, no me gusta pero funciona bien.

Ejemplo:

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)

Puede lograr mucho más simplemente usando log4jAPI.
Fuente: [ Documentos de configuración de Log4J , sección Configuración]

# 2 Pase log4j.propertiesdurantespark-submit

Este es muy complicado, pero no imposible. Y mi favorito

Log4J durante el inicio de la aplicación siempre está buscando y cargando log4j.propertiesarchivos desde classpath.

Sin embargo, cuando se usa spark-submitel classpath de Spark Cluster tiene prioridad sobre el classpath de la aplicación. ¡Es por eso que poner este archivo en su fat-jar no anulará la configuración del clúster!

Añadir -Dlog4j.configuration=<location of configuration file>a spark.driver.extraJavaOptions (para el controlador) o
spark.executor.extraJavaOptions (para los ejecutores) .

Tenga en cuenta que si usa un archivo, el file:protocolo debe proporcionarse explícitamente y el archivo debe existir localmente en todos los nodos .

Para satisfacer la última condición, puede cargar el archivo en la ubicación disponible para los nodos (como hdfs) o acceder a él localmente con el controlador si lo usa deploy-mode client. De otra manera:

cargue un archivo personalizado log4j.propertiesmediante spark-submit, agregándolo a la --fileslista de archivos que se cargarán con la aplicación.

Fuente: documentos de Spark, depuración

Pasos:

Ejemplo 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

Ejecución spark-submit, para el modo de clúster:

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"

Tenga en cuenta que debe usar --driver-java-optionssi usa el clientmodo. Spark docs, Runtime env

Ejecución spark-submit, para modo cliente:

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"

Notas:

1. Los archivos cargados spark-clustercon --filesestarán disponibles en el directorio raíz, por lo que no es necesario agregar ninguna ruta file:log4j.properties.
2. ¡Los archivos listados en --filesdeben ser provistos con una ruta absoluta!
3. file: El prefijo en la configuración URI es obligatorio.

# 3 Editar clústeres conf/log4j.properties

Esto cambia el archivo de configuración de registro global .

actualice el $SPARK_CONF_DIR/log4j.propertiesarchivo y se cargará automáticamente junto con las otras configuraciones.

Fuente: documentos de Spark, depuración

Para encontrar tu SPARK_CONF_DIRpuedes usar 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

Ahora solo edite /var/lib/spark/latest/conf/log4j.properties(con el ejemplo del método # 2) y todas sus aplicaciones compartirán esta configuración.

# 4 Anular directorio de configuración

Si le gusta la solución n. ° 3, pero desea personalizarla por aplicación, puede copiar la confcarpeta, editar el contenido y especificarla como la configuración raíz durante spark-submit.

Para especificar un directorio de configuración diferente al predeterminado “SPARK_HOME/conf”, puede establecerlo SPARK_CONF_DIR. Spark utilizará los archivos de configuración ( spark-defaults.conf, spark-env.sh, log4j.properties, etc. ) desde este directorio.

Fuente: Spark docs, Configuración

Pasos:

1. Copie la confcarpeta del clúster (más información, método # 3)
2. Edite log4j.propertiesen esa carpeta (ejemplo en el método # 2)

3. Establezca SPARK_CONF_DIRen esta carpeta, antes de ejecutar spark-submit,
   ejemplo:

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

Conclusión

No estoy seguro de si hay algún otro método, pero espero que esto cubra el tema de la A a la Z. Si no, ¡no dudes en enviarme un comentario!

¡Disfruta tu camino!

Establece deshabilitar los registros configurando su nivel en OFF de la siguiente manera:

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

o edite el archivo de registro y desactive el nivel de registro simplemente cambiando la siguiente propiedad:

log4j.rootCategory=OFF, console

Solo agrego esta línea a todos mis scripts de pyspark en la parte superior, justo debajo de las declaraciones de importación.

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

ejemplo de encabezado de mis scripts de pyspark

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

Las respuestas anteriores son correctas, pero no me ayudaron exactamente, ya que necesitaba información adicional.

Acabo de configurar Spark para que el archivo log4j todavía tenga el sufijo '.template' y no se esté leyendo. Creo que el inicio de sesión predeterminado es Spark core logging conf.

Entonces, si eres como yo y descubres que las respuestas anteriores no te ayudaron, entonces tal vez también debas eliminar el sufijo '.template' de tu archivo conf de log4j y ¡entonces lo anterior funciona perfectamente!

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

En Python / Spark podemos hacer:

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 )

Después de definir Sparkcontaxt 'sc', llame a esta función por: quiet_logs (sc)

tl; dr

Para Spark Context puedes usar:

sc.setLogLevel(<logLevel>)

donde loglevelpuede estar ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE o WARN.

Detalles-

Internamente, setLogLevelllamadas org.apache.log4j.Level.toLevel(logLevel)que luego usa para configurar el uso org.apache.log4j.LogManager.getRootLogger().setLevel(level).

Puede establecer directamente los niveles de registro para OFFusar:

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

Puede configurar el inicio de sesión predeterminado para Spark Shell en conf/log4j.properties. Úselo conf/log4j.properties.templatecomo punto de partida.

Establecer niveles de registro en aplicaciones de Spark

En las aplicaciones independientes de Spark o durante la sesión de Spark Shell, use lo siguiente:

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

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

Deshabilitar el registro (en log4j):

Use lo siguiente conf/log4j.propertiespara deshabilitar el registro por completo:

log4j.logger.org=OFF

Referencia: Mastering Spark por Jacek Laskowski.

Simple de hacer en la línea de comando ...

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

Simplemente agregue el siguiente parámetro a su comando spark-shell O spark-submit

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

Verifique el nombre exacto de la propiedad (log4jspark.root.logger aquí) del archivo log4j.properties. Espero que esto ayude, ¡salud!

Una idea interesante es usar el RollingAppender como se sugiere aquí: http://shzhangji.com/blog/2015/05/31/spark-streaming-logging-configuration/ para que no "contamine" el espacio de la consola, pero aún podrá ver los resultados en $ 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

Otro método que resuelve la causa es observar qué tipo de registros usualmente tiene (provenientes de diferentes módulos y dependencias), y establecer para cada uno la granularidad para el registro, mientras se vuelven registros "silenciosos" de terceros que son demasiado detallados:

Por ejemplo,

    # 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. Ajuste conf / log4j.properties como lo describe otro log4j.rootCategory = ERROR, consola
2. Asegúrese de que mientras ejecuta su trabajo de chispa pasa - bandera de archivo con ruta de archivo log4j.properties
3. Si todavía no funciona, es posible que tenga un jar que tenga log4j.properties que se llama antes que su nuevo log4j.properties. Elimine ese log4j.properties del jar (si corresponde)

sparkContext.setLogLevel("OFF")

Además de todas las publicaciones anteriores, esto es lo que resolvió el problema para mí.

Spark usa slf4j para unirse a los registradores. Si log4j no es el primer enlace encontrado, puede editar los archivos log4j.properties todo lo que desee, ni siquiera se utilizan los registradores. Por ejemplo, esto podría ser una posible salida SLF4J:

SLF4J: la ruta de clase contiene varios enlaces SLF4J. SLF4J: Enlace encontrado en [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: Enlace encontrado en [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: Consulte http://www.slf4j.org/codes.html#multiple_bindings para obtener una explicación. SLF4J: el enlace real es del tipo [org.slf4j.impl.SimpleLoggerFactory]

Entonces, aquí se usó SimpleLoggerFactory, que no se preocupa por la configuración de log4j.

Excluyendo el paquete slf4j-simple de mi proyecto a través de

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

resolvió el problema, ya que ahora se utiliza el enlace log4j logger y se cumple cualquier configuración en log4j.properties. FYI mi archivo de propiedades log4j contiene (además de la configuración normal)

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

¡Espero que esto ayude!

Este me funcionó. Para que solo se muestren mensajes de ERROR como stdout, el log4j.propertiesarchivo puede verse así:

# 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

NOTA: Ponga el log4j.propertiesarchivo en la src/main/resourcescarpeta para que sea efectivo. Y si log4j.propertiesno existe (el significado sparkes usar el log4j-defaults.propertiesarchivo), puede crearlo yendo a SPARK_HOME/confy luego mv log4j.properties.template log4j.propertiesy luego continuar con los cambios mencionados anteriormente.

Si no tiene la capacidad de editar el código Java para insertar las .setLogLevel()declaraciones y no desea que se implementen aún más archivos externos, puede usar una forma de fuerza bruta para resolver esto. Simplemente filtre las líneas INFO con grep.

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

Si alguien más está atrapado en esto,

nada de lo anterior funcionó para mí. Tuve que quitar

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'

desde mi build.gradle para que los registros desaparezcan. TLDR: no importe ningún otro marco de registro, debería estar bien simplemente usandoorg.apache.log4j.Logger

Otra forma de detener registros por completo es:

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

        }
    }

Esto funcionó para mí. Un NullAppender es

Un Appender que ignora los eventos de registro. ( https://logging.apache.org/log4j/2.x/log4j-core/apidocs/org/apache/logging/log4j/core/appender/NullAppender.html )