Gostaria de interromper várias mensagens que estão chegando no shell de faísca.

Tentei editar o log4j.propertiesarquivo para interromper essas mensagens.

Aqui estão os conteúdos 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

Mas as mensagens ainda estão sendo exibidas no console.

Aqui estão algumas mensagens de exemplo

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

Como eu paro isso?

Edite seu conf/log4j.propertiesarquivo e altere a seguinte linha:

log4j.rootCategory=INFO, console

para

log4j.rootCategory=ERROR, console

Outra abordagem seria:

Inicie o spark-shell e digite o seguinte:

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

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

Você não verá nenhum registro depois disso.

Outras opções para o Nível incluem: all, debug, error, fatal, info, off, trace, trace_int,warn

Detalhes sobre cada um podem ser encontrados na documentação.

Logo após o início do spark-shelltipo;

sc.setLogLevel("ERROR")

No Spark 2.0 (Scala):

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

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

Obrigado, AkhlD e @Sachin Janani, por sugerirem alterações no .conf arquivo.

O código a seguir resolveu meu problema:

1) Adicionado import org.apache.log4j.{Level, Logger} na seção de importação

2) Adicionada a seguinte linha após a criação do objeto de contexto spark, ou seja, após val sc = new SparkContext(conf):

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

Use o comando abaixo para alterar o nível do log ao enviar o aplicativo usando 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"

Nota: substitua <file path>onde o log4jarquivo de configuração está armazenado.

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>

Alterne para FileAppender em log4j.xml se desejar gravar registros em arquivo em vez de console. LOG_DIRé uma variável para o diretório de logs que você pode fornecer usando 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>

Outra coisa importante a entender aqui é que, quando o trabalho é iniciado no modo distribuído (cluster no modo de implantação e mestre como fio ou mesos), o arquivo de configuração log4j deve existir nos nós do driver e do trabalhador ( log4j.configuration=file:<file path>/log4j.xml), caso contrário, o log4j init irá reclamar.

log4j: ERRO Não foi possível ler o arquivo de configuração [log4j.properties]. java.io.FileNotFoundException: log4j.properties (Nenhum arquivo ou diretório desse tipo)

Dica para resolver esse problema

Mantenha o arquivo de configuração log4j no sistema de arquivos distribuído (HDFS ou mesos) e inclua a configuração externa usando o log4j PropertyConfigurator . ou use sparkContext addFile para disponibilizá-lo em cada nó e use log4j PropertyConfigurator para recarregar a configuração.

Todos os métodos coletados com exemplos

Introdução

Na verdade, existem muitas maneiras de fazer isso . Alguns são mais difíceis dos outros, mas cabe a você qual deles melhor lhe convém. Vou tentar mostrar todos eles.

Nº 1 programaticamente em seu aplicativo

Parece ser o mais fácil, mas você precisará recompilar seu aplicativo para alterar essas configurações. Pessoalmente, não gosto, mas funciona bem.

Exemplo:

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)

Você pode conseguir muito mais usando a log4jAPI.
Fonte: [ Log4J Configuration Docs , seção Configuration]

# 2 Passe log4j.propertiesdurantespark-submit

Este é muito complicado, mas não impossível. E a minha favorita.

O Log4J durante a inicialização do aplicativo está sempre procurando e carregando o log4j.propertiesarquivo do caminho de classe.

No entanto, ao usar spark-submit o caminho de classe do Spark Cluster, prevalece sobre o caminho de classe do aplicativo! É por isso que colocar esse arquivo no seu jar de gordura não substituirá as configurações do cluster!

Adicionar -Dlog4j.configuration=<location of configuration file>a spark.driver.extraJavaOptions (para o driver) ou
spark.executor.extraJavaOptions (para executores) .

Observe que, se estiver usando um arquivo, o file:protocolo deve ser fornecido explicitamente, e o arquivo precisa existir localmente em todos os nós .

Para satisfazer a última condição, você pode carregar o arquivo no local disponível para os nós (como hdfs) ou acessá-lo localmente com o driver, se estiver usandodeploy-mode client . De outra forma:

faça o upload de um costume log4j.propertiesusando o envio por spark, adicionando-o ao--files lista de arquivos a serem carregados com o aplicativo.

Fonte: documentos do Spark, Depuração

Passos:

Exemplo 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

Executando spark-submit, para modo de 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"

Observe que você deve usar --driver-java-optionsse estiver usando o clientmodo. Documentos do Spark, ambiente de tempo de execução

Executando spark-submit, para o 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. Os arquivos enviados para spark-clustercom --filesestarão disponíveis no diretório raiz, portanto, não há necessidade de adicionar nenhum caminho no diretório raiz.file:log4j.properties .
2. Os arquivos listados em --filesdevem ser fornecidos com o caminho absoluto!
3. file: prefixo na configuração URI é obrigatório.

# 3 Editar agrupamentos conf/log4j.properties

Isso altera o arquivo de configuração de log global .

atualize o $SPARK_CONF_DIR/log4j.propertiesarquivo e ele será automaticamente carregado junto com as outras configurações.

Origem: documentos do Spark, Depuração

Para encontrar o seu, SPARK_CONF_DIRvocê pode 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

Agora basta editar /var/lib/spark/latest/conf/log4j.properties(com o exemplo do método 2) e todos os seus aplicativos compartilharão essa configuração.

# 4 Substituir diretório de configuração

Se você gosta da solução nº 3, mas deseja personalizá-la por aplicativo, pode copiar a confpasta, editá-la e especificar como a configuração raiz durante spark-submit.

Para especificar um diretório de configuração diferente do padrão “SPARK_HOME/conf”, você pode definir SPARK_CONF_DIR. Faísca vai usar os arquivos de configuração ( spark-defaults.conf, spark-env.sh,log4j.properties , etc ) a partir deste diretório.

Fonte: Spark docs, Configuração

Passos:

1. Copiar cluster conf pasta (mais informações, método nº 3)
2. Editar log4j.properties nessa pasta (exemplo no método nº 2)

3. Defina SPARK_CONF_DIRpara esta pasta, antes de executar spark-submit,
   exemplo:

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

Conclusão

Não tenho certeza se existe algum outro método, mas espero que isso aborde o tópico de A a Z. Caso contrário, sinta-se à vontade para me enviar um ping nos comentários!

Aproveite o seu caminho!

Você define desativar os logs, definindo seu nível como OFF da seguinte maneira:

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

ou edite o arquivo de log e defina o nível de log como desativado, apenas alterando a seguinte propriedade:

log4j.rootCategory=OFF, console

Acabei de adicionar esta linha a todos os meus scripts pyspark na parte superior, logo abaixo das instruções de importação.

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

exemplo cabeçalho dos meus scripts pyspark

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

As respostas acima estão corretas, mas não me ajudaram exatamente, pois havia informações adicionais necessárias.

Acabei de configurar o Spark para que o arquivo log4j ainda tivesse o sufixo '.template' e não estivesse sendo lido. Eu acredito que o log padrão é o conf do log principal do Spark.

Portanto, se você é como eu e acha que as respostas acima não ajudaram, talvez você também precise remover o sufixo '.template' do seu arquivo log4j conf e, em seguida, o procedimento acima funciona perfeitamente!

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

No Python / Spark, podemos fazer:

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 )

O após a definição do Sparkcontaxt 'sc' chama essa função de: quiet_logs (sc)

tl; dr

Para o Contexto Spark, você pode usar:

sc.setLogLevel(<logLevel>)

onde loglevelpode ser ALL, DEBUG, ERRO, FATAL, INFO, OFF, TRACE ou WARN.

Detalhes-

Internamente, setLogLevelchama org.apache.log4j.Level.toLevel(logLevel)que ele usa para definir o uso org.apache.log4j.LogManager.getRootLogger().setLevel(level).

Você pode definir diretamente os níveis de log para OFFusar:

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

Você pode configurar o log padrão para o shell Spark conf/log4j.properties. Use conf/log4j.properties.templatecomo ponto de partida.

Definindo níveis de log em aplicativos Spark

Nos aplicativos independentes do Spark ou na sessão do Spark Shell, use o seguinte:

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

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

Desativando o log (no log4j):

Use o seguinte conf/log4j.propertiespara desativar completamente o log:

log4j.logger.org=OFF

Referência: Mastering Spark de Jacek Laskowski.

Simples de fazer na linha de comando ...

spark2-submit --driver-java-options="-Droot.logger=ERROR,console" ..outras opções..

Basta adicionar abaixo do parâmetro ao seu comando spark-shell OR spark-submit

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

Verifique o nome exato da propriedade (log4jspark.root.logger aqui) no arquivo log4j.properties. Espero que isso ajude, felicidades!

Uma idéia interessante é usar o RollingAppender conforme sugerido aqui: http://shzhangji.com/blog/2015/05/31/spark-streaming-logging-configuration/ para que você não "polua" o espaço do console, mas ainda poderá ver os resultados em $ 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

Outro método que resolve a causa é observar que tipo de log você costuma ter (proveniente de diferentes módulos e dependências) e definir para cada granularidade para o log, ao ativar logs "silenciosos" de terceiros que são muito detalhados:

Por exemplo,

    # 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 conforme descrito por outro log4j.rootCategory = ERROR, console
2. Certifique-se de que, ao executar sua tarefa spark, você passe o sinalizador --file com o caminho do arquivo log4j.properties
3. Se ainda assim não funcionar, você pode ter um jar com log4j.properties que está sendo chamado antes do seu novo log4j.properties. Remova esse log4j.properties do jar (se apropriado)

sparkContext.setLogLevel("OFF")

Além de todas as postagens acima, aqui está o que resolveu o problema para mim.

O Spark usa slf4j para ligar aos registradores. Se log4j não for a primeira ligação encontrada, você poderá editar os arquivos log4j.properties conforme desejar, os registradores nem sequer serão utilizados. Por exemplo, isso poderia ser uma saída possível do SLF4J:

SLF4J: O caminho da classe contém várias ligações SLF4J. SLF4J: Ligação encontrada em [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: ligação encontrada em [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 obter uma explicação. SLF4J: A ligação real é do tipo [org.slf4j.impl.SimpleLoggerFactory]

Portanto, aqui foi utilizado o SimpleLoggerFactory, que não se importa com as configurações do log4j.

Excluindo o pacote slf4j-simple do meu projeto via

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

resolveu o problema, agora que a ligação do log4j logger é usada e qualquer configuração no log4j.properties é respeitada. Para sua informação, meu arquivo de propriedades log4j contém (além da configuração 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 isto ajude!

Este funcionou para mim. Para que apenas as mensagens de ERRO sejam exibidas como stdout, o log4j.propertiesarquivo pode se parecer com:

# 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: Coloque o log4j.propertiesarquivo na src/main/resourcespasta para ser eficaz. E se log4j.propertiesnão existe (significado sparkestá usando log4j-defaults.propertiesarquivo), então você pode criá-lo, indo para SPARK_HOME/confe, em seguida, mv log4j.properties.template log4j.propertiese, em seguida, continuar com dito acima mudanças.

Se você não tem a capacidade de editar o código java para inserir as .setLogLevel()instruções e não deseja implantar mais arquivos externos, pode usar uma maneira de força bruta para resolver isso. Apenas filtre as linhas INFO usando grep.

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

Se mais alguém estiver preso nisso,

nada do acima funcionou para mim. Eu tive que remover

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'

do meu build.gradle para os logs desaparecerem. TLDR: não importe nenhuma outra estrutura de log, você deve ficar bem usandoorg.apache.log4j.Logger

Outra maneira de parar completamente os logs é:

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

        }
    }

Isso funcionou para mim. Um NullAppender é

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