Chciałbym zatrzymać różne komunikaty, które pojawiają się w powłoce iskry.

Próbowałem edytować log4j.propertiesplik, aby zatrzymać te komunikaty.

Oto zawartość 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

Ale komunikaty nadal są wyświetlane na konsoli.

Oto kilka przykładowych wiadomości

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

Jak to zatrzymać?

Edytuj conf/log4j.propertiesplik i zmień następujący wiersz:

log4j.rootCategory=INFO, console

do

log4j.rootCategory=ERROR, console

Innym podejściem byłoby:

Uruchom osłonę iskrową i wpisz:

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

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

Po tym nie zobaczysz żadnych dzienników.

Inne opcje obejmują Level: all, debug, error, fatal, info, off, trace, trace_int,warn

Szczegóły dotyczące każdego z nich można znaleźć w dokumentacji.

Zaraz po uruchomieniu spark-shelltypu;

sc.setLogLevel("ERROR")

W Spark 2.0 (Scala):

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

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

W przypadku języka Java:

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

Dzięki @AkhlD i @Sachin Janani za sugestie zmian w .confpliku.

Poniższy kod rozwiązał mój problem:

1) Dodano import org.apache.log4j.{Level, Logger}w sekcji importu

2) Dodano następujący wiersz po utworzeniu obiektu kontekstu iskry, czyli po val sc = new SparkContext(conf):

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

Użyj poniższego polecenia, aby zmienić poziom dziennika podczas składania wniosku przy użyciu funkcji spark-submit lub 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"

Uwaga: wymień <file path>gdzielog4j przechowywany jest plik konfiguracyjny.

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>

Przełącz się do FileAppender w log4j.xml, jeśli chcesz zapisywać dzienniki w pliku zamiast w konsoli. LOG_DIRjest zmienną dla katalogu logów, którą możesz podać za pomocą 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>

Inną ważną rzeczą do zrozumienia jest to, że gdy zadanie jest uruchamiane w trybie rozproszonym (klaster w trybie wdrażania i master jako przędza lub mesos), plik konfiguracyjny log4j powinien istnieć w węzłach sterownika i węzła roboczego ( log4j.configuration=file:<file path>/log4j.xml), w przeciwnym razie log4j init będzie narzekał.

log4j: BŁĄD Nie można odczytać pliku konfiguracyjnego [log4j.properties]. java.io.FileNotFoundException: log4j.properties (Brak takiego pliku lub katalogu)

Wskazówka dotycząca rozwiązania tego problemu-

Zachowaj plik konfiguracyjny log4j w rozproszonym systemie plików (HDFS lub mesos) i dodaj konfigurację zewnętrzną za pomocą narzędzia log4j PropertyConfigurator . lub użyj funkcji sparkContext addFile, aby udostępnić ją w każdym węźle, a następnie użyj narzędzia log4j PropertyConfigurator do ponownego załadowania konfiguracji.

Wszystkie metody zebrane z przykładami

Intro

Właściwie jest na to wiele sposobów . Niektóre są trudniejsze od innych, ale od Ciebie zależy, który z nich najbardziej Ci odpowiada. Postaram się je wszystkie pokazać.

# 1 Programowo w Twojej aplikacji

Wydaje się, że jest to najłatwiejsze, ale musisz ponownie skompilować aplikację, aby zmienić te ustawienia. Osobiście mi się to nie podoba, ale działa dobrze.

Przykład:

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)

Dzięki log4jAPI możesz osiągnąć znacznie więcej .
Źródło: [ Log4J Configuration Docs , Configuration section]

# 2 Pass w log4j.propertiestrakciespark-submit

To jest bardzo trudne, ale nie niemożliwe. I mój ulubiony.

Log4J podczas uruchamiania aplikacji zawsze szuka i ładuje log4j.properties plik ze ścieżki klasy.

Jednak w przypadku korzystania spark-submitze ścieżki klas Spark Clustera ma pierwszeństwo przed ścieżką klas aplikacji! Dlatego umieszczenie tego pliku w Twoim fat-jar nie nadpisuje ustawień klastra!

Dodaj -Dlog4j.configuration=<location of configuration file>do spark.driver.extraJavaOptions (dla sterownika) lub
spark.executor.extraJavaOptions (dla wykonawców) .

Zauważ, że jeśli używasz pliku, file:protokół powinien być jawnie dostarczony, a plik musi istnieć lokalnie na wszystkich węzłach .

Aby spełnić ostatni warunek, możesz przesłać plik do lokalizacji dostępnej dla węzłów (np. hdfs) Lub uzyskać do niego dostęp lokalnie za pomocą sterownika, jeśli używasz deploy-mode client. Inaczej:

przesłać niestandardowy log4j.propertiesprzy użyciu funkcji spark-submit, dodając go do --fileslisty plików do przesłania wraz z aplikacją.

Źródło: dokumentacja Spark, debugowanie

Kroki:

Przykład 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

Wykonywanie spark-submit, dla trybu klastra:

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"

Pamiętaj, że musisz użyć, --driver-java-optionsjeśli używasz clienttrybu.Spark docs, środowisko wykonawcze środowiska uruchomieniowego

Wykonywanie spark-submit, dla trybu klienta:

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"

Uwagi:

1. Pliki przesłane do spark-clusterz--files będą dostępne w głównym katalogu, więc nie ma potrzeby, aby dodać dowolną ścieżkęfile:log4j.properties .
2. Pliki wymienione w --filesmuszą mieć bezwzględną ścieżkę!
3. file: prefiks w identyfikatorze URI konfiguracji jest obowiązkowy.

# 3 Edytuj klaster conf/log4j.properties

Spowoduje to zmianę pliku konfiguracji globalnego rejestrowania .

zaktualizuj $SPARK_CONF_DIR/log4j.propertiesplik, a zostanie on automatycznie przesłany wraz z innymi konfiguracjami.

Źródło: dokumentacja Spark, debugowanie

Aby znaleźć swój SPARK_CONF_DIR, możesz użyć 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

Teraz po prostu edytuj /var/lib/spark/latest/conf/log4j.properties(przykład z metody nr 2), a wszystkie Twoje aplikacje będą współdzielić tę konfigurację.

# 4 Zastąp katalog konfiguracji

Jeśli podoba Ci się rozwiązanie nr 3, ale chcesz dostosować je do poszczególnych aplikacji, możesz skopiować conffolder, edytować jego zawartość i określić jako konfigurację główną podczas spark-submit.

Aby określić inny katalog konfiguracji niż domyślny “SPARK_HOME/conf”, możesz ustawić SPARK_CONF_DIR. Spark będzie korzystać z plików konfiguracyjnych ( spark-defaults.conf, spark-env.sh, log4j.properties, etc ) z tego katalogu.

Źródło: dokumentacja Spark, konfiguracja

Kroki:

1. Skopiuj plik klastra conf folder (więcej informacji, metoda nr 3)
2. Edytuj log4j.propertiesw tym folderze (przykład w metodzie nr 2)

3. Ustaw SPARK_CONF_DIRna ten folder, przed wykonaniem spark-submit,
   przykład:

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

Wniosek

Nie jestem pewien, czy istnieje inna metoda, ale mam nadzieję, że obejmuje ona temat od A do Z. Jeśli nie, pisz do mnie w komentarzach!

Ciesz się swoją drogą!

Aby wyłączyć dzienniki, należy ustawić jego poziom na WYŁ. W następujący sposób:

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

lub edytuj plik dziennika i wyłącz poziom logowania, zmieniając po prostu następującą właściwość:

log4j.rootCategory=OFF, console

Po prostu dodaję tę linię do wszystkich moich skryptów pyspark na górze tuż pod instrukcjami importu.

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

przykładowy nagłówek moich skryptów pyspark

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

Powyższe odpowiedzi są poprawne, ale nie pomogły mi, ponieważ potrzebowałem dodatkowych informacji.

Właśnie skonfigurowałem Sparka, więc plik log4j nadal miał sufiks „.template” i nie był odczytywany. Uważam, że rejestrowanie jest wtedy domyślnie ustawione na Spark core logging conf.

Więc jeśli jesteś podobny do mnie i stwierdzisz, że powyższe odpowiedzi nie pomogły, być może Ty też musisz usunąć sufiks „.template” z pliku conf log4j, a wtedy powyższe działa doskonale!

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

W Python / Spark możemy:

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 )

Po zdefiniowaniu Sparkcontaxt 'sc' wywołaj tę funkcję przez: quiet_logs (sc)

tl; dr

W przypadku Spark Context możesz użyć:

sc.setLogLevel(<logLevel>)

gdzie loglevelmoże być ALL, DEBUG, ERROR, FATAL, INFO, OFF, TRACE lub WARN.

Detale-

Wewnętrznie setLogLevelwywołuje org.apache.log4j.Level.toLevel(logLevel), których następnie używa do ustawiania using org.apache.log4j.LogManager.getRootLogger().setLevel(level).

Możesz bezpośrednio ustawić poziomy logowania OFFza pomocą:

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

Możesz skonfigurować domyślne rejestrowanie dla powłoki Spark w conf/log4j.properties. Użyj conf/log4j.properties.templatejako punktu wyjścia.

Ustawianie poziomów dzienników w aplikacjach Spark

W autonomicznych aplikacjach Spark lub podczas sesji Spark Shell użyj następujących elementów:

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

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

Wyłączanie logowania (w log4j):

conf/log4j.propertiesAby całkowicie wyłączyć rejestrowanie, użyj następujących poleceń:

log4j.logger.org=OFF

Literatura: Mastering Spark by Jacek Laskowski.

Proste do zrobienia w wierszu poleceń ...

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

Po prostu dodaj poniższy parametr do polecenia spark-shell LUB spark-submit

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

Sprawdź dokładną nazwę właściwości (tutaj log4jspark.root.logger) z pliku log4j.properties. Mam nadzieję, że to pomoże!

Ciekawym pomysłem jest użycie RollingAppendera zgodnie z sugestią tutaj: http://shzhangji.com/blog/2015/05/31/spark-streaming-logging-configuration/ , aby nie „polutować” przestrzeni konsoli, ale nadal można zobaczyć wyniki w $ 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

Inną metodą, która rozwiązuje tę przyczynę, jest obserwacja, jakiego rodzaju logi zwykle masz (pochodzące z różnych modułów i zależności) i ustawienie dla każdego z nich szczegółowości rejestrowania, jednocześnie zmieniając „ciche” dzienniki stron trzecich, które są zbyt szczegółowe:

Na przykład,

    # 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. Dostosuj conf / log4j.properties zgodnie z opisem w innym log4j.rootCategory = ERROR, konsola
2. Upewnij się, że podczas wykonywania zadania iskry przekazałeś flagę --file ze ścieżką do pliku log4j.properties
3. Jeśli nadal nie działa, być może masz jar, który ma log4j.properties, który jest wywoływany przed nowym log4j.properties. Usuń ten plik log4j.properties z pliku jar (jeśli to konieczne)

sparkContext.setLogLevel("OFF")

Oprócz wszystkich powyższych postów, oto, co rozwiązało problem.

Spark używa slf4j do tworzenia powiązań z rejestratorami. Jeśli log4j nie jest pierwszym znalezionym powiązaniem, możesz edytować pliki log4j.properties, ile chcesz, programy rejestrujące nie są nawet używane. Na przykład może to być możliwe wyjście SLF4J:

SLF4J: ścieżka klasy zawiera wiele powiązań SLF4J. SLF4J: Znaleziono powiązanie w [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: Znaleziono powiązanie w [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: Zobacz http://www.slf4j.org/codes.html#multiple_bindings, aby uzyskać wyjaśnienie. SLF4J: Rzeczywiste powiązanie jest typu [org.slf4j.impl.SimpleLoggerFactory]

Więc tutaj wykorzystano SimpleLoggerFactory, który nie dba o ustawienia log4j.

Wykluczając pakiet slf4j-simple z mojego projektu za pośrednictwem

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

rozwiązano ten problem, ponieważ teraz jest używane powiązanie programu rejestrującego log4j i są przestrzegane wszelkie ustawienia w log4j.properties. Do Twojej wiadomości mój plik właściwości log4j zawiera (oprócz normalnej konfiguracji)

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

Mam nadzieję że to pomoże!

Ten pracował dla mnie. Aby tylko komunikaty o błędach były wyświetlane jako stdout, log4j.propertiesplik może wyglądać następująco:

# 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

UWAGA: Umieść log4j.propertiesplik w src/main/resourcesfolderze, aby działał. A jeśli log4j.propertiesnie istnieje (czyli sparkużywa log4j-defaults.propertiespliku), a następnie można go utworzyć, przechodząc do SPARK_HOME/conf, a następnie mv log4j.properties.template log4j.properties, a następnie postępuj zgodnie ze wskazówkami powyżej wspomnianej zmiany.

Jeśli nie masz możliwości edytowania kodu java w celu wstawienia .setLogLevel()instrukcji i nie chcesz wdrażać kolejnych plików zewnętrznych, możesz użyć metody brutalnej siły, aby rozwiązać ten problem. Po prostu odfiltruj wiersze INFO za pomocą grepa.

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

Jeśli ktoś jeszcze w tym tkwi,

nic z powyższych nie działało dla mnie. Musiałem usunąć

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'

z mojego build.gradle, aby dzienniki zniknęły. TLDR: Nie importuj żadnych innych struktur rejestrowania, powinno być dobrze po prostu używającorg.apache.log4j.Logger

Innym sposobem całkowitego zatrzymania dzienników jest:

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

        }
    }

To zadziałało dla mnie. NullAppender to

Appender, który ignoruje zdarzenia dziennika. ( https://logging.apache.org/log4j/2.x/log4j-core/apidocs/org/apache/logging/log4j/core/appender/NullAppender.html )