Lokinkeruukäytännöt projekteissa: teknologiat, työkalut ja parhaat käytännöt

Nykyaikaisessa ohjelmistokehityksessä lokikirjaus on kriittinen osa järjestelmän vakauden varmistamista, vianetsintää ja suorituskyvyn seurantaa. Tässä artikkelissa perehdytään käytännön kokemuksiin lokinkeruusta projekteissa ja esitellään lokinkeruutekniikoita, työkaluja ja joitain Java-projekteissa yleisesti käytettyjä parhaita käytäntöjä.

1. Valitse sopiva kirjauskehys

Java-projekteissa sopivan lokikehyksen valitseminen on ensimmäinen askel lokin keräämisessä. Yleisiä kirjauskehyksiä ovat Log4j, Logback ja SLF4J. Tässä on joitain huomioita kehyksen valinnassa:

esitys: Tietyt puitteet voivat toimia paremmin suorituskyvyn suhteen, joten valitse sopiva projektisi tarpeiden mukaan.
joustavuus: Jotkin puitteet tarjoavat joustavampia konfigurointi- ja tulostusvaihtoehtoja sopeutuakseen erilaisiin sovellusskenaarioihin.
Yhteisön tuki: Valitse kehys, jossa on aktiivinen yhteisön tuki ja jatkuvat päivitykset varmistaaksesi, että ongelmat ratkaistaan oikea-aikaisesti ja pääset käyttämään uusimpia ominaisuuksia.

2. Määritä lokikehys

Kun olet valinnut lokikehyksen, se on konfiguroitava asianmukaisesti vastaamaan projektin tarpeita. Yleisesti ottaen määritystiedostot ovat yleensä XML- tai ominaisuustiedostoja, jotka sisältävät tietoa lokitasoista, tulostusmuodoista, kohdepaikoista jne.

Kun otetaan esimerkkinä Logback, yksinkertainen asetustiedostoesimerkki on seuraava:


<!-- logback.xml -->
<configuration>
 
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>logs/myapp.log</file>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <logger name="com.example" level="DEBUG"/>
    
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
 
</configuration>

Yllä oleva konfiguraatio määrittelee kaksi liitettä, toinen konsolin ulostulolle ja toinen tiedostotulolle, ja määrittää lokin tason ja tulostusmuodon.

3. Käytä asianmukaisia lokitasoja

Asianmukaisten kirjaustasojen käyttäminen projektissasi on yksi avaintekijöistä, joilla varmistetaan kirjausjärjestelmäsi maksimaalinen tehokkuus. Sopivan lokitason valitseminen voi varmistaa, että eri ympäristöissä ja vaiheissa saadaan sopiva taso yksityiskohtaisia lokitietoja, samalla kun vältetään liian monta tai liian vähän lokeja järjestelmän suorituskyvyn ja ylläpidettävyyden parantamiseksi.

1. Yleiskatsaus lokitasoihin

Java-lokikehyksessä yleisiä lokitasoja ovat:

JÄLJITTÄÄ: Tarjoaa yksityiskohtaisimmat lokitiedot, joita käytetään usein virheenkorjaukseen.
DEBUG: Tarjoaa yksityiskohtia virheenkorjausta varten, sopii kehitys- ja testiympäristöihin.
TIEDOT: Tarjoaa tärkeitä ajonaikaisia tietoja, jotka osoittavat, että sovellus toimii oikein.
VAROITTAA: Osoittaa mahdollisia ongelmia, jotka saattavat vaatia huomiota, mutta jotka eivät vaikuta ohjelman normaaliin toimintaan.
VIRHE: Osoittaa, että on tapahtunut virhe ja lisäkäsittely saattaa olla tarpeen.

2. Valitse sopiva lokitaso (ota esimerkkinä logbkck)

Käytä DEBUGia kehitysvaiheen aikana: Käytä kehitysvaiheessa DEBUG-tasoa saadaksesi yksityiskohtaisempia lokitietoja, joiden avulla kehittäjät voivat seurata ja korjata koodia.


public class ExampleClass {
    private static final Logger logger = LoggerFactory.getLogger(ExampleClass.class);
 
    public void someMethod() {
        // ...
        logger.debug("Debug information for developers");
        // ...
    }
}

Tuotantoympäristö käyttää INFOa: Aseta tuotantoympäristössä lokitasoksi INFO varmistaaksesi, että kriittiset ajonaikaiset tiedot kirjataan lokiin ja vähennät samalla ylimääräisiä virheenkorjaustietoja.

Varoitus ja virheiden käsittely: Käytä mahdollisia ongelmia ja virhetilanteita varten WARN- ja ERROR-tasoja. Nämä kirjaustasot auttavat tiimejä nopeasti tunnistamaan ja ratkaisemaan järjestelmän ongelmat.

3. Säädä lokitasoja dynaamisesti

Jotkin lokikehykset mahdollistavat lokitason dynaamisen säätämisen ajon aikana, mikä voi olla hyödyllistä säädettäessä kirjauksen monimuotoisuutta käynnistämättä sovellusta uudelleen.

Käyttämällä asianmukaisia lokitasoja kehitystiimit voivat paremmin tasapainottaa tiedon yksityiskohtia ja suorituskykyä, mikä varmistaa optimaaliset kirjaustulokset eri ympäristöissä ja skenaarioissa.

4. Yhdistetty lokin kontekstitietoihin

Lokin kontekstitietojen yhdistäminen lisää kontekstitietoja lokitietueisiin ymmärtääksesi paremmin lokitapahtumien taustaa. Tämä on hyödyllistä seurata tiettyjä pyyntöjä, käyttäjäistuntoja tai muita liiketoimintaprosesseja. Java-projekteissa yleinen käytäntö on käyttää SLF4J:n MDC:tä (Mapped Diagnostic Context) tai Log4j 2:n ThreadContextia lokin kontekstitietojen lisäämiseen.

1. SLF4J MDC:n käyttö

SLF4J:n MDC mahdollistaa avainarvotietojen lisäämisen lokikontekstiin pyynnön tai liiketoimintaprosessin sisällä, jotta ne säilyvät koko käsittelyn ajan.


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
 
public class RequestContextLogger {
    private static final Logger logger = LoggerFactory.getLogger(RequestContextLogger.class);
 
    public void processRequest(String requestId, String userId) {
        try {
            // 将请求ID和用户ID放入日志上下文
            MDC.put("requestId", requestId);
            MDC.put("userId", userId);
 
            // 处理请求
            logger.info("Processing request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing request", e);
        } finally {
            // 清理日志上下文，确保不影响其他请求
            MDC.clear();
        }
    }
}

2. Log4j 2:n ThreadContextin käyttäminen

Log4j 2 tarjoaa ThreadContextin, joka on samanlainen kuin SLF4J:n MDC ja joka voi myös tallentaa säikeen laajuuden avainarvoparien kontekstitietoja.


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.ThreadContext;
 
public class RequestContextLogger {
    private static final Logger logger = LogManager.getLogger(RequestContextLogger.class);
 
    public void processRequest(String requestId, String userId) {
        try {
            // 将请求ID和用户ID放入日志上下文
            ThreadContext.put("requestId", requestId);
            ThreadContext.put("userId", userId);
 
            // 处理请求
            logger.info("Processing request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing request", e);
        } finally {
            // 清理日志上下文，确保不影响其他请求
            ThreadContext.clearAll();
        }
    }
}

3. Hyödynnä kontekstuaalista tietoa

Lokin kontekstuaalisen tiedon sisällyttämisen etuna on, että voit yhdistää toisiinsa liittyviä lokitapahtumia, mikä helpottaa tietyn pyynnön tai käyttäjän toimintojen kulun jäljittämistä. Esimerkiksi hajautetussa järjestelmässä koko pyyntöjen käsittelyprosessi voidaan jäljittää useissa palveluissa lisäämällä lokiin yksilöllinen pyyntötunnus.


public class DistributedService {
    private static final Logger logger = LoggerFactory.getLogger(DistributedService.class);
 
    public void processDistributedRequest(String requestId) {
        try {
            MDC.put("requestId", requestId);
 
            // 处理分布式请求
            logger.info("Processing distributed request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing distributed request", e);
        } finally {
            MDC.clear();
        }
    }
}

Yhdistämällä asiayhteyteen liittyviä tietoja lokitietueet eivät enää ole yksittäisiä tapahtumia, vaan ne ovat orgaanisesti yhteydessä toisiinsa, mikä tarjoaa tehokkaamman työkalun järjestelmän vianmääritykseen ja suorituskyvyn optimointiin.

5. Reaaliaikainen seuranta ja keskitetty tallennus

Reaaliaikainen seuranta ja keskitetty tallennus ovat tärkeitä lokinhallinnan näkökohtia projektissa. Näiden keinojen avulla tiimi voi seurata järjestelmän toimintatilaa reaaliajassa, havaita mahdolliset ongelmat ja suorittaa vianmäärityksen tarvittaessa. Java-projekteissa yleisesti käytettyjä työkaluja ovat ELK Stack (Elasticsearch, Logstash, Kibana), Splunk jne.

1. ELK Stack (Elasticsearch, Logstash, Kibana)

ELK Stack on joukko avoimen lähdekoodin työkaluja lokien keräämiseen, tallentamiseen ja visualisointiin.

Joustohaku: Käytetään suurten lokitietojen tallentamiseen ja hakemiseen. Se tarjoaa tehokkaat haku- ja analysointiominaisuudet reaaliaikaisille tiedoille.
Logstash: Käytetään lokin keräämiseen, suodattamiseen ja edelleenlähettämiseen. Logstash voi normalisoida lokitiedot eri lähteistä ja lähettää ne Elasticsearchille tallennettavaksi.
Kibana: Tarjoaa intuitiivisen käyttöliittymän Elasticsearchiin tallennettujen lokitietojen kyselyyn, visualisointiin ja analysointiin. Kibanan avulla tiimit voivat luoda koontinäyttöjä, kaavioita ja analysoida lokitietoja perusteellisesti.

2. Määritä Logstash keräämään lokeja

Logstashin määrittäminen projektissa keräämään lokeja on kriittinen vaihe ELK Stackille. Logstash tukee useita tulolähteitä ja tulostuskohteita, jotka voidaan määrittää yksinkertaisten konfigurointitiedostojen avulla.


# logstash.conf
 
input {
    file {
        path => "/path/to/your/application.log"
        start_position => "beginning"
    }
}
 
filter {
    # 可添加过滤规则
}
 
output {
    elasticsearch {
        hosts => ["localhost:9200"]
        index => "your_index_name"
    }
}

Tämä esimerkki määrittää Logstash-syöttölaajennuksen valvomaan määritetyn polun lokitiedostoja ja tulostamaan ne Elasticsearchille. Suodatinosio voi lisätä lisäsääntöjä jäsentää, suodattaa tai lisätä lisätietoja lokeihin.

3. Käytä Kibanaa visualisointiin ja analysointiin

Kibana tarjoaa intuitiivisen käyttöliittymän, johon pääsee verkkoselaimen kautta. Kibanassa voit luoda koontinäyttöjä, kaavioita ja suorittaa monimutkaisia kyselyitä ja analyyseja.

Kibanan avulla voit helposti:

reaaliaikainen seuranta: Tarkastele reaaliaikaisia lokitietoja ja ymmärrä järjestelmän toimintatila milloin tahansa.
Ongelmien karttoittaminen: Hae lokeista tiettyjen kriteerien perusteella löytääksesi mahdollisten ongelmien perimmäisen syyn.
Suorituskykyanalyysi: Käytä kaavioita ja visualisointityökaluja analysoidaksesi järjestelmän suorituskyvyn pullonkauloja.

4. Splunk

Splunk on toinen laajalti käytetty lokinhallintatyökalu, joka tarjoaa all-in-one-ratkaisun lokien keräämiseen, etsimiseen, analysointiin ja visualisointiin.

Tukkikokoelma: Splunk tukee lokitietojen keräämistä useista lähteistä (tiedostot, tietokannat, verkkoliikenne jne.).
Reaaliaikainen haku ja analyysi: Tarjoaa reaaliaikaisia haku- ja analyysitoimintoja, tukee monimutkaisia kyselyitä ja näyttää hakutulokset visuaalisen käyttöliittymän kautta.
Hallintapaneelit ja raportit: Käyttäjät voivat luoda mukautettuja kojetauluja ja raportteja järjestelmän suorituskyvyn seurantaa ja analysointia varten.

5. Keskitetty tallennus ja skaalautuvuus

Sekä ELK Stackissa että Splunkissa on tehokkaat keskitetyt tallennusmekanismit, jotka voivat tallentaa suuria määriä lokitietoja. Tämä keskitetty tallennus ei ainoastaan helpota lokien hakua ja analysointia, vaan tarjoaa myös järjestelmälle skaalautuvuuden ja pystyy käsittelemään suuria sovelluslokeja.

Johtopäätös

Reaaliaikainen seuranta ja keskitetty tallennus ovat avainasemassa projektin vakauden ja suorituskyvyn varmistamisessa. Käyttämällä työkaluja, kuten ELK Stack ja Splunk, projektitiimi voi seurata lokeja reaaliajassa monimutkaisissa järjestelmäympäristöissä ja suorittaa oikea-aikaista vianetsintää ja suorituskyvyn optimointia. Näiden työkalujen teho ei ainoastaan paranna tiimin tehokkuutta, vaan tarjoaa myös projekteille paremman ylläpidettävyyden ja skaalautuvuuden.

6. Lokin rullaus ja arkistointi

Lokin rullaus ja arkistointi ovat tärkeitä käytäntöjä projektissa. Se varmistaa lokitiedostojen järkevän hallinnan, ehkäisee ylimääräisten lokitiedostojen aiheuttamia säilytysongelmia ja auttaa ylläpitämään järjestelmän normaalia toimintaa. Seuraavassa on joitain yleisiä käytäntöjä lokin rullauksen ja arkistoinnin toteuttamiseksi Java-projekteissa.

1. Määritä lokikehyksen rullaava strategia

Useimmat lokikehykset tarjoavat rullattavia strategioita, jotka voidaan määrittää määritystiedostojen kautta. Nämä käytännöt määrittävät, milloin siirrytään uusiin lokitiedostoihin ja milloin vanhat lokitiedostot poistetaan. Kun otetaan esimerkkinä Logback, määritä rullaava perusstrategia:


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.log</fileNamePattern>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

Yllä oleva kokoonpano käyttääTimeBasedRollingPolicy, joka rullaa lokitiedoston ajan mukaan.maxHistoryMäärittää säilytettävien historiallisten lokitiedostojen määrän, jotka ylittävät tämän määrän, poistetaan.

2. Vieritys tiedoston koon mukaan

Joskus rullaaminen ei välttämättä riitä, ja sinun on myös rullattava lokitiedoston koon perusteella. Tämä voidaan saavuttaa määrittämällä tiedostokoko:


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <maxFileSize>5MB</maxFileSize>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

Yllä oleva kokoonpano käyttääSizeAndTimeBasedRollingPolicy, joka rullaa lokitiedostoja tiedoston koon ja ajan perusteella.maxFileSizeMäärittää kunkin lokitiedoston enimmäiskoon.

3. Mukauta vieritysstrategiaa

Joskus projektit saattavat joutua rullaamaan lokit mukautettujen olosuhteiden perusteella. Harkitse tässä tapauksessa mukautetun vieritysstrategian käyttöönottoa. Esimerkiksi rullaavat lokitiedostot tiettyjen liiketoimintasääntöjen perusteella:


public class CustomRollingPolicy extends TimeBasedRollingPolicy<ILoggingEvent> {
    // 实现自定义的滚动逻辑
}

Käytä sitten mukautettua vieritysstrategiaa asetustiedostossa:


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="com.example.CustomRollingPolicy">
        <!-- 自定义配置 -->
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

4. Arkistoi vanhat lokitiedostot

Lokitiedostojen rullaamisen lisäksi myös vanhojen lokitiedostojen arkistointi on yleinen käytäntö. Tämä voidaan saavuttaa siirtämällä vanhoja lokitiedostoja säännöllisesti arkistohakemistoon, jotta ne eivät vie liikaa levytilaa.

Tai käytä ohjelmallista lähestymistapaa sen toteuttamiseen Java-koodissa:


import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
 
public class LogArchiver {
    public static void archiveLogFile(String logFileName, String archiveDirectory) {
        String currentDate = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        File logFile = new File(logFileName);
        File archiveDir = new File(archiveDirectory);
 
        if (!archiveDir.exists()) {
            archiveDir.mkdirs();
        }
 
        Path sourcePath = logFile.toPath();
        Path targetPath = new File(archiveDir, logFile.getName() + "." + currentDate + ".log").toPath();
 
        try {
            Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Kutsuttiin säännöllisiin tehtäviinarchiveLogFileTätä menetelmää voidaan käyttää lokitiedostojen arkistointiin.

Ottamalla käyttöön lokin rullauksen ja arkistoinnin projektit voivat hallita lokitiedostoja tehokkaammin ja varmistaa järjestelmän hyvän suorituskyvyn pitkiä aikoja. Tämä ei ole hyödyllinen vain vianmäärityksessä, vaan myös vaatimustenmukaisuusvaatimusten täyttämisessä.

Johtopäätös

Valitsemalla sopivan lokikehyksen, määrittämällä sen asianmukaisesti, käyttämällä asianmukaisia lokitasoja ja yhdistämällä kontekstitietoja, projektit voivat rakentaa tehokkaan lokijärjestelmän, joka tarjoaa vahvan tuen vianmääritykseen, suorituskyvyn optimointiin ja järjestelmän valvontaan. Samaan aikaan reaaliaikainen valvonta ja keskitetty tallennus tarjoavat tiimeille kätevämpiä tapoja seurata järjestelmän tilaa. Huolellinen hakkuu ei ole vain tekninen käytäntö projektikehityksessä, vaan myös tärkeä tae tiimin kokonaistehokkuuden ja projektin laadun parantamiselle.

Teknologian jakaminen