Come interrompere la visualizzazione dei messaggi INFO sulla Spark Console?


181

Vorrei fermare vari messaggi che arrivano su Spark Shell.

Ho provato a modificare il log4j.propertiesfile per interrompere questo messaggio.

Ecco i contenuti di 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

Ma i messaggi vengono ancora visualizzati sulla console.

Ecco alcuni messaggi di esempio

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

Come posso fermarli?

Risposte:


168

Modifica il tuo conf/log4j.propertiesfile e cambia la seguente riga:

log4j.rootCategory=INFO, console

per

log4j.rootCategory=ERROR, console

Un altro approccio sarebbe quello di:

Avviare spark-shell e digitare quanto segue:

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

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

Successivamente non vedrai alcun registro.

Altre opzioni per il livello includono: all, debug, error, fatal, info, off, trace, trace_int,warn

I dettagli su ciascuno di essi possono essere trovati nella documentazione.


15
Penso che OFF sia troppo restrittivo. WARN o ERRORE potrebbero adattarsi meglio qui.
snowindy,

2
Aggiungilo ai tuoi progetti Classe principale.
AkhlD,

2
Bella risposta. Qualche modo di fare lo stesso da PySpark a livello di codice?
Tagar,

2
La parte programmatica di questo non funziona. Invece questa risposta da @cantdutchthis stackoverflow.com/a/37836847/1056563
javadba

1
Chi è questo @AkhlD?
Aviad Klein

151

Subito dopo aver iniziato a spark-shellscrivere;

sc.setLogLevel("ERROR")

In Spark 2.0 (Scala):

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

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

Per Java:

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

Come imposteresti questa proprietà in un programma?
Alex Raj Kaliamoorthy,

Questo è disponibile solo per spark.sql.SparkSession o anche avaibale per JavaSparkContext ??
SharpLu,

Sì, è disponibile per JavaSparkContext . Grazie, @cantdutchthis. Questo mi ha infastidito per un po '.
alan,

1
Questa è l'unica risposta che ha funzionato per me senza creare un log4j separato. Grazie!
abhihello123,

2
Funziona per me, tuttavia sto ancora ricevendo un paio di messaggi all'inizio del mio test. Qualche idea?

46

Grazie @AkhlD e @Sachin Janani per aver suggerito cambiamenti nel .conffile.

Il seguente codice ha risolto il mio problema:

1) Aggiunto import org.apache.log4j.{Level, Logger}nella sezione di importazione

2) Aggiunta la seguente riga dopo la creazione dell'oggetto di contesto spark, ovvero dopo val sc = new SparkContext(conf):

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

12
Ho provato questo, ma ancora ottenere gli output di registrazione.
horatio1701d,

1
Mi piace questa soluzione come non avere il permesso di accedere a conf /
Jim Ho,

31

Utilizzare il comando seguente per modificare il livello di registro durante l'invio dell'applicazione mediante 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: sostituire <file path>dove log4jè archiviato il file di configurazione.

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>

Passare a FileAppender in log4j.xml se si desidera scrivere registri su file anziché su console. LOG_DIRè una variabile per la directory dei registri che è possibile fornire utilizzando 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>

Un'altra cosa importante da capire qui è che quando il lavoro viene avviato in modalità distribuita (cluster in modalità deploy e master come thread o mesos) il file di configurazione log4j dovrebbe esistere su nodi driver e worker ( log4j.configuration=file:<file path>/log4j.xml) altrimenti log4j init si lamenterà-

log4j: ERRORE Impossibile leggere il file di configurazione [log4j.properties]. java.io.FileNotFoundException: log4j.properties (nessun file o directory del genere)

Suggerimento su come risolvere questo problema

Conservare il file di configurazione log4j nel file system distribuito (HDFS o mesos) e aggiungere la configurazione esterna utilizzando logCj PropertyConfigurator . oppure utilizzare sparkContext addFile per renderlo disponibile su ciascun nodo, quindi utilizzare log4j PropertyConfigurator per ricaricare la configurazione.


2
Questo è uno dei pochi esempi che non ostruisce tutti i orglog che sono tradizionalmente dal logger predefinito.
deepelement

1
Funziona molto bene, ma a cosa serve il Log4j.propertiesfile? Non sembra essere usato. Stai semplicemente documentando le proprietà impostate nel file XML?
vy32,

1
Puoi usare uno di loro.
Rahul Sharma,

3
Ho avuto successo con quanto sopra: lo uso --filesnel comando spark-submit per rendere log4j.properties disponibile su tutti i nodi.
Ben Watson,

1
Questa è l'unica soluzione che ha funzionato per me e non comporta alcuna modifica del codice. Crea un file Log4.propertiessotto main/resourcesnel caso in cui non esista
Yeikel

30

Tutti i metodi raccolti con esempi

Intro

In realtà, ci sono molti modi per farlo . Alcuni sono più difficili da altri, ma dipende da te quale ti si addice meglio. Proverò a mostrarli tutti.


# 1 A livello di codice nella tua app

Sembra essere il più semplice, ma dovrai ricompilare la tua app per modificare tali impostazioni. Personalmente, non mi piace ma funziona benissimo.

Esempio:

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)

Puoi ottenere molto di più semplicemente utilizzando l' log4jAPI.
Fonte: [ Documenti di configurazione Log4J , sezione Configurazione]


# 2 Passa log4j.propertiesdurantespark-submit

Questo è molto complicato, ma non impossibile. E il mio preferito.

Log4J all'avvio dell'app cerca e carica sempre i log4j.propertiesfile dal percorso di classe.

Tuttavia, quando si utilizza spark-submitil percorso di classe di Spark Cluster ha la precedenza sul percorso di classe dell'app! Questo è il motivo per cui mettere questo file nel tuo barattolo di grasso non sovrascriverà le impostazioni del cluster!

Aggiungi -Dlog4j.configuration=<location of configuration file>a spark.driver.extraJavaOptions (per il driver) o
spark.executor.extraJavaOptions (per gli esecutori) .

Se si utilizza un file, file:è necessario fornire esplicitamente il protocollo e il file deve esistere localmente su tutti i nodi .

Per soddisfare l'ultima condizione, è possibile caricare il file nella posizione disponibile per i nodi (come hdfs) o accedervi localmente con il driver se si utilizza deploy-mode client. Altrimenti:

carica un custom log4j.propertiesusando spark-submit, aggiungendolo --filesall'elenco dei file da caricare con l'applicazione.

Fonte: documenti Spark, debug

passi:

Esempio 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

In esecuzione spark-submit, per la modalità 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"

Si noti che è necessario utilizzare --driver-java-optionsse si utilizza la clientmodalità.Spark docs, Runtime env

In esecuzione spark-submit, per la modalità 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"

Appunti:

  1. File caricati in spark-clustercon--files saranno disponibili nella directory principale, quindi non è necessario aggiungere alcun percorso file:log4j.properties.
  2. I file elencati in --filesdevono essere forniti con percorso assoluto!
  3. file: il prefisso nell'URI di configurazione è obbligatorio.

# 3 Modifica i cluster conf/log4j.properties

Ciò modifica il file di configurazione della registrazione globale .

aggiorna il $SPARK_CONF_DIR/log4j.propertiesfile e verrà automaticamente caricato insieme alle altre configurazioni.

Fonte: documenti Spark, debug

Per trovare il SPARK_CONF_DIRtuo puoi usare 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

Ora modifica /var/lib/spark/latest/conf/log4j.properties(con l'esempio del metodo n. 2) e tutte le tue app condivideranno questa configurazione.


# 4 Sostituisci la directory di configurazione

Se ti piace la soluzione n. 3, ma desideri personalizzarla per applicazione, puoi effettivamente copiare la confcartella, modificarne il contenuto e specificare come configurazione root durante spark-submit.

Per specificare una directory di configurazione diversa da quella predefinita “SPARK_HOME/conf”, è possibile impostare SPARK_CONF_DIR. Spark utilizzerà i file di configurazione ( spark-defaults.conf, spark-env.sh, log4j.properties, ecc ) da questa directory.

Fonte: Spark docs, Configurazione

passi:

  1. Copia la confcartella del cluster (ulteriori informazioni, metodo n. 3)
  2. Modifica log4j.propertiesin quella cartella (esempio nel metodo n. 2)
  3. Impostare SPARK_CONF_DIRsu questa cartella, prima di eseguire spark-submit,
    esempio:

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

Conclusione

Non sono sicuro che ci sia un altro metodo, ma spero che questo copra l'argomento dalla A alla Z. Altrimenti, sentitevi liberi di chiamarmi nei commenti!

Buon divertimento!


Questa dovrebbe essere la risposta accettata. Offre molti dettagli e riassume molti più casi d'uso rispetto agli altri. (Senza incoraggiare a disabilitare i log.)
belgacea

@Atais - Dovresti aggiungere qui sotto Quindi, se sei come me e scopri che le risposte sopra non sono state di aiuto, allora forse anche tu devi rimuovere il suffisso '.template' dal tuo file di configurazione di log4j e quindi quanto sopra funziona perfettamente!
giorno

1
Nota aggiuntiva sull'approccio programmatico- Il livello deve essere impostato prima della creazione di SparkContext
SparkContext

@ArunrajNair non dovrebbe essere il caso, perché la registrazione è una funzione separata, non connessa a SparkContext.
Atais,

19

È possibile disabilitare i registri impostando il suo livello su OFF come segue:

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

o modifica il file di registro e disattiva il livello del registro semplicemente modificando la seguente proprietà:

log4j.rootCategory=OFF, console

In quale file devo impostare sopra le proprietà ??
Vishwas era il

Puoi aggiungere queste righe nel tuo programma Driver @Vishwas
Sachin Janani

Ho aggiunto lo stesso ma i log appaiono ancora sulla console
Vishwas il

Hai modificato la proprietà log4j.rootCategory = OFF. Ho testato questi alla mia fine e funziona bene
Sachin Janani

3
Questo non fa differenza per me su Spark 2.3.1
Toby Eggitt,

15

Aggiungo solo questa riga a tutti i miei script pyspark in alto appena sotto le dichiarazioni di importazione.

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

intestazione di esempio dei miei script pyspark

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

13
Funziona, ma non ferma le 58 righe di messaggi INFO che compaiono durante la creazione del contesto Spark.
vy32,

1
Nota che questo è per Spark 2.x
Yeikel

13

Le risposte sopra sono corrette ma non mi hanno aiutato esattamente perché c'erano ulteriori informazioni richieste.

Ho appena installato Spark, quindi il file log4j aveva ancora il suffisso '.template' e non veniva letto. Ritengo che la registrazione venga impostata automaticamente su Spark core logging conf.

Quindi, se sei come me e scopri che le risposte sopra non sono state d'aiuto, allora forse anche tu devi rimuovere il suffisso '.template' dal tuo file di log4j conf e quindi quanto sopra funziona perfettamente!

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


Controlla questa risposta, stackoverflow.com/a/51554118/2094086 spero che tu stia cercando lo stesso.
Gaurav Adurkar,

5

In Python / Spark possiamo fare:

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 )

Il dopo aver definito Sparkcontaxt 'sc' chiama questa funzione da: quiet_logs (sc)


Mi piacerebbe trovare un modo programmatico che funzioni senza fare confusione con il file log4j, ma quando ci provo ancora ricevo avvisi come WARN org.apache.spark.scheduler.TaskSetManager: attività 612.1 persa nella fase 0.0 (TID 2570 ..., esecutore 15): TaskKilled (un altro
tentativo

5

tl; dr

Per Spark Context è possibile utilizzare:

sc.setLogLevel(<logLevel>)

dove loglevelpossono essere ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE o WARN.


Dettagli-

Internamente, setLogLevelchiama org.apache.log4j.Level.toLevel(logLevel)che quindi utilizza per impostare usando org.apache.log4j.LogManager.getRootLogger().setLevel(level).

È possibile impostare direttamente i livelli di registrazione su OFFutilizzando:

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

È possibile impostare la registrazione predefinita per la shell Spark in conf/log4j.properties. Utilizzare conf/log4j.properties.templatecome punto di partenza.

Impostazione dei livelli di registro nelle applicazioni Spark

Nelle applicazioni Spark indipendenti o durante la sessione di Spark Shell, utilizzare quanto segue:

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

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

Disabilitazione della registrazione (in log4j):

Utilizzare quanto segue conf/log4j.propertiesper disabilitare completamente la registrazione:

log4j.logger.org=OFF

Riferimento: Mastering Spark di Jacek Laskowski.


3

Semplice da fare sulla riga di comando ...

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


che cos'è spark2-submit?
vy32,

spark2-submit viene utilizzato per Spark2.
Nephilim,

3

Aggiungi semplicemente param sotto al tuo comando spark-shell O spark-submit

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

Controlla il nome esatto della proprietà (log4jspark.root.logger qui) dal file log4j.properties. Spero che questo aiuti, evviva!


1
Impostarlo dalla riga di comando sarebbe fantastico. Ma questo non ha funzionato per me.
swdev,

2

Un'idea interessante è utilizzare RollingAppender come suggerito qui: http://shzhangji.com/blog/2015/05/31/spark-streaming-logging-configuration/ in modo da non "inquinare" lo spazio della console, ma essere ancora in grado di vedere i risultati in $ 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

Un altro metodo che risolve la causa è quello di osservare che tipo di registrazioni si hanno di solito (provenienti da diversi moduli e dipendenze) e impostare per ciascuno la granularità per la registrazione, mentre si trasformano registri di terze parti "silenziosi" che sono troppo dettagliati:

Per esempio,

    # 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. Regola conf / log4j.properties come descritto da altri log4j.rootCategory = ERRORE, console
  2. Accertati che durante l'esecuzione del tuo processo di accensione passi il flag --file con il percorso del file log4j.properties
  3. Se il problema persiste, è possibile che sia presente un jar con log4j.properties che viene chiamato prima del nuovo log4j.properties. Rimuovi quel log4j.properties dal vaso (se appropriato)

0
sparkContext.setLogLevel("OFF")

1
Ho rimosso entrambi il suffisso .template da log4j.properties e impostato il livello su ERRORE, e ha val rootLogger = Logger.getRootLogger() rootLogger.setLevel(Level.ERROR) funzionato
Sam-T

0

Oltre a tutti i post sopra, ecco cosa mi ha risolto il problema.

Spark utilizza slf4j per collegarsi ai logger. Se log4j non è il primo binding trovato, è possibile modificare i file log4j.properties tutto ciò che si desidera, i logger non vengono nemmeno utilizzati. Ad esempio, questo potrebbe essere un possibile output SLF4J:

SLF4J: il percorso di classe contiene più associazioni SLF4J. SLF4J: Trovato il binding 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: Trovato associazione in [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: vedi http://www.slf4j.org/codes.html#multiple_bindings per una spiegazione. SLF4J: L'associazione effettiva è di tipo [org.slf4j.impl.SimpleLoggerFactory]

Quindi qui è stato utilizzato SimpleLoggerFactory, a cui non interessano le impostazioni di log4j.

Escludendo il pacchetto slf4j-simple dal mio progetto tramite

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

risolto il problema, poiché ora viene utilizzata l'associazione del logger log4j e viene rispettata qualsiasi impostazione in log4j.properties. Cordiali saluti il ​​mio file delle proprietà log4j contiene (oltre alla normale configurazione)

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

Spero che questo ti aiuti!


0

Questo ha funzionato per me. Per visualizzare solo i messaggi di ERRORE come stdout, il log4j.propertiesfile può apparire come:

# 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: mettere il log4j.propertiesfile nella src/main/resourcescartella per essere efficace. E se log4j.propertiesnon esiste (il significato sparksta utilizzando il log4j-defaults.propertiesfile), è possibile crearlo andando su SPARK_HOME/confe quindi mv log4j.properties.template log4j.propertiese quindi procedere con le suddette modifiche.


0

Se non si ha la possibilità di modificare il codice java per inserire le .setLogLevel()istruzioni e non si desidera distribuire ancora più file esterni, è possibile utilizzare un metodo di forza bruta per risolvere il problema. Basta filtrare le righe INFO usando grep.

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

0

Se qualcun altro è bloccato su questo,

nulla di quanto sopra ha funzionato per me. Ho dovuto rimuovere

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'

dal mio build.gradle per far scomparire i log. TLDR: non importare nessun altro framework di logging, dovresti semplicemente usareorg.apache.log4j.Logger


0

Un altro modo per arrestare completamente i registri è:

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

        }
    }

Questo ha funzionato per me. Un NullAppender è

Un Appender che ignora gli eventi del registro. ( https://logging.apache.org/log4j/2.x/log4j-core/apidocs/org/apache/logging/log4j/core/appender/NullAppender.html )

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.