从elk迁移日志到loggie+clickhouse(开发侧非实施侧)

最新推荐文章于 2024-07-22 10:49:54 发布
最新推荐文章于 2024-07-22 10:49:54 发布
阅读量729 收藏 1
点赞数
文章标签： elk clickhouse java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45069429/article/details/127557734
版权

原始架构 ：
在这里插入图片描述
（网图····）
现有架构：
在这里插入图片描述
(也是网图,流程log4j2->loggi-kafka->clickVisual)
loggie(https://blog.csdn.net/easylife206/article/details/123540177)
现有痛点：海外业务为节省ecs es等基础资源(利用clickhou行式存储和压缩效率)
开发支持
logback(公司原有日志框架)->log4j2(注意异步队列监控)

<?xml version="1.0" encoding="UTF-8"?>
<!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
<!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
<configuration monitorInterval="5">
    <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->

    <!--变量配置-->
    <Properties>
        <!-- 格式化输出：%date表示日期，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %msg：日志消息，%n是换行符-->
        <!-- %logger{36} 表示 Logger 名字最长36个字符 -->
        <property name="Console_PATTERN" value="%highlight{%d{DEFAULT} traceId:%traceId %T %-5level  %c %m %l %msg%n}{FATAL=Bright Red, ERROR=Bright Magenta, WARN=Bright Yellow, INFO=Bright Green, DEBUG=Bright Cyan, TRACE=Bright White}" />
        <!-- 定义日志存储的路径，不要配置相对路径 -->
        <property name="FILE_PATH" value="/opt/logs/xxx" />
        <property name="FILE_NAME" value="loggie" />
        <property name="env">${sys:env}</property>
    </Properties>

    <appenders>

        <console name="Console" target="SYSTEM_OUT">
            <!--输出日志的格式-->
            <PatternLayout pattern="${Console_PATTERN}"/>
<!--            <LogJsonLayout compact="true" locationInfo="true" complete="false" eventEol="true" properties="true" propertiesAsList="true" appName="xxxxx" env="${env}"/>-->
            <!--控制台只输出level及其以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
        </console>

        

        <!-- 这个会打印出所有的info及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileInfo" fileName="${FILE_PATH}/loggie-info.log" filePattern="${FILE_PATH}/${FILE_NAME}-INFO-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="info" onMatch="ACCEPT" onMismatch="DENY"/>
<!--            <PatternLayout pattern="${LOG_PATTERN}"/>-->
<!--            <PatternLayout pattern="[%d{HH:mm:ss:SSS}] [%p] - %l - %m%n" />-->
            <LogJsonLayout compact="true" locationInfo="true" complete="false" eventEol="true" properties="true" propertiesAsList="true" appName="xxxx" env="${env}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的warn及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileWarn" fileName="${FILE_PATH}/loggie-warn.log" filePattern="${FILE_PATH}/${FILE_NAME}-WARN-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="warn" onMatch="ACCEPT" onMismatch="DENY"/>
<!--            <PatternLayout pattern="${LOG_PATTERN}"/>-->
            <LogJsonLayout compact="true" locationInfo="true" complete="false" eventEol="true" properties="true" propertiesAsList="true" appName="xxxx" env="${env}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

        <!-- 这个会打印出所有的error及以下级别的信息，每次大小超过size，则这size大小的日志会自动存入按年份-月份建立的文件夹下面并进行压缩，作为存档-->
        <RollingFile name="RollingFileError" fileName="${FILE_PATH}/loggie-error.log" filePattern="${FILE_PATH}/${FILE_NAME}-ERROR-%d{yyyy-MM-dd}_%i.log.gz">
            <!--控制台只输出level及以上级别的信息（onMatch），其他的直接拒绝（onMismatch）-->
            <ThresholdFilter level="error" onMatch="ACCEPT" onMismatch="DENY"/>
<!--            <PatternLayout pattern="${LOG_PATTERN}"/>-->
            <LogJsonLayout compact="true" locationInfo="true" complete="false" eventEol="true" properties="true" propertiesAsList="true" appName="xxxx" env="${env}"/>
            <Policies>
                <!--interval属性用来指定多久滚动一次，默认是1 hour-->
                <TimeBasedTriggeringPolicy interval="1"/>
                <SizeBasedTriggeringPolicy size="10MB"/>
            </Policies>
            <!-- DefaultRolloverStrategy属性如不设置，则默认为最多同一文件夹下7个文件开始覆盖-->
            <DefaultRolloverStrategy max="15"/>
        </RollingFile>

    </appenders>

    <!--Logger节点用来单独指定日志的形式，比如要为指定包下的class指定不同的日志级别等。-->
    <!--然后定义loggers，只有定义了logger并引入的appender，appender才会生效-->
    <loggers>

        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
        <AsyncLogger name="org.mybatis" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </AsyncLogger>
        <!--监控系统信息-->
        <!--若是additivity设为false，则 子Logger 只会在自己的appender里输出，而不会在 父Logger 的appender里输出。-->
        <AsyncLogger name="org.springframework" level="info" additivity="false">
            <AppenderRef ref="Console"/>
        </AsyncLogger>

        <AsyncLogger name="com.log4j2.Log4j2" level="error">
            <AppenderRef ref="Console"/>
        </AsyncLogger>

        <AsyncLogger name="org.apache.zookeeper" level="error">
            <AppenderRef ref="Console"/>
        </AsyncLogger>

        <AsyncLogger name="io.shardingsphere" level="error">
            <AppenderRef ref="Console"/>
            <AppenderRef ref="RollingFileInfo"/>
        </AsyncLogger>

        <Asyncroot level="DEBUG"  includeLocation="false">
            <appender-ref ref="Console"/>
            <appender-ref ref="RollingFileInfo"/>
            <appender-ref ref="RollingFileWarn"/>
            <appender-ref ref="RollingFileError"/>
        </Asyncroot>

    </loggers>

</configuration>

日志格式处理：


import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.DefaultConfiguration;
import org.apache.logging.log4j.core.config.Node;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
import org.apache.logging.log4j.core.config.plugins.PluginConfiguration;
import org.apache.logging.log4j.core.config.plugins.PluginFactory;
import org.apache.logging.log4j.core.layout.PatternLayout;

import java.io.IOException;
import java.io.Writer;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

@Plugin(name = "LogJsonLayout", category = Node.CATEGORY, elementType = Layout.ELEMENT_TYPE, printObject = true)
public final class LogJsonLayout extends AbstractJacksonLayout {

    private static final String DEFAULT_FOOTER = "]";

    private static final String DEFAULT_HEADER = "[";

    private static final String APP_NAME="";

    private static final String ENV="";

    static final String CONTENT_TYPE = "application/json";

    protected LogJsonLayout(final Configuration config, final boolean locationInfo, final boolean properties,
                            final boolean encodeThreadContextAsList,
                            final boolean complete, final boolean compact, final boolean eventEol, final String headerPattern,
                            final String footerPattern, final Charset charset, final String appName, final String env, final boolean includeStacktrace) {
        super(config, new JacksonFactory.JSON(encodeThreadContextAsList, includeStacktrace).newWriter(
                locationInfo, properties, compact),
                charset,appName,env, compact, complete, eventEol,
                PatternLayout.createSerializer((org.apache.logging.log4j.core.config.Configuration) config, null, headerPattern, DEFAULT_HEADER, null, false, false),
                PatternLayout.createSerializer((org.apache.logging.log4j.core.config.Configuration) config, null, footerPattern, DEFAULT_FOOTER, null, false, false)
        );
    }

    /**
     * Returns appropriate JSON header.
     *
     * @return a byte array containing the header, opening the JSON array.
     */
    @Override
    public byte[] getHeader() {
        if (!this.complete) {
            return null;
        }
        final StringBuilder buf = new StringBuilder();
        final String str = serializeToString(getHeaderSerializer());
        if (str != null) {
            buf.append(str);
        }
        buf.append(this.eol);
        return getBytes(buf.toString());
    }

    /**
     * Returns appropriate JSON footer.
     *
     * @return a byte array containing the footer, closing the JSON array.
     */
    @Override
    public byte[] getFooter() {
        if (!this.complete) {
            return null;
        }
        final StringBuilder buf = new StringBuilder();
        buf.append(this.eol);
        final String str = serializeToString(getFooterSerializer());
        if (str != null) {
            buf.append(str);
        }
        buf.append(this.eol);
        return getBytes(buf.toString());
    }

    @Override
    public Map<String, String> getContentFormat() {
        final Map<String, String> result = new HashMap<>();
        result.put("version", "2.0");
        return result;
    }

    @Override
    /**
     * @return The content type.
     */
    public String getContentType() {
        return CONTENT_TYPE + "; charset=" + this.getCharset();
    }

    /**
     * Creates a JSON Layout.
     * @param config
     *           The plugin configuration.
     * @param locationInfo
     *            If "true", includes the location information in the generated JSON.
     * @param properties
     *            If "true", includes the thread context map in the generated JSON.
     * @param propertiesAsList
     *            If true, the thread context map is included as a list of map entry objects, where each entry has
     *            a "key" attribute (whose value is the key) and a "value" attribute (whose value is the value).
     *            Defaults to false, in which case the thread context map is included as a simple map of key-value
     *            pairs.
     * @param complete
     *            If "true", includes the JSON header and footer, and comma between records.
     * @param compact
     *            If "true", does not use end-of-lines and indentation, defaults to "false".
     * @param eventEol
     *            If "true", forces an EOL after each log event (even if compact is "true"), defaults to "false". This
     *            allows one even per line, even in compact mode.
     * @param headerPattern
     *            The header pattern, defaults to {@code "["} if null.
     * @param footerPattern
     *            The header pattern, defaults to {@code "]"} if null.
     * @param charset
     *            The character set to use, if {@code null}, uses "UTF-8".
     * @param includeStacktrace
     *            If "true", includes the stacktrace of any Throwable in the generated JSON, defaults to "true".
     * @return A JSON Layout.
     */
    @PluginFactory
    public static LogJsonLayout createLayout(
            // @formatter:off
            @PluginConfiguration final Configuration config,
            @PluginAttribute(value = "locationInfo", defaultBoolean = false) final boolean locationInfo,
            @PluginAttribute(value = "properties", defaultBoolean = false) final boolean properties,
            @PluginAttribute(value = "propertiesAsList", defaultBoolean = false) final boolean propertiesAsList,
            @PluginAttribute(value = "complete", defaultBoolean = false) final boolean complete,
            @PluginAttribute(value = "compact", defaultBoolean = false) final boolean compact,
            @PluginAttribute(value = "eventEol", defaultBoolean = false) final boolean eventEol,
            @PluginAttribute(value = "header", defaultString = DEFAULT_HEADER) final String headerPattern,
            @PluginAttribute(value = "footer", defaultString = DEFAULT_FOOTER) final String footerPattern,
            @PluginAttribute(value = "charset", defaultString = "UTF-8") final Charset charset,
            @PluginAttribute(value = "appName", defaultString = "UTF-8") final String appName,
            @PluginAttribute(value = "env", defaultString = "UTF-8") final String env,
            @PluginAttribute(value = "includeStacktrace", defaultBoolean = true) final boolean includeStacktrace
            // @formatter:on
    ) {
        final boolean encodeThreadContextAsList = properties && propertiesAsList;
        return new LogJsonLayout(config, locationInfo, properties, encodeThreadContextAsList, complete, compact, eventEol,
                headerPattern, footerPattern, charset,appName, env,includeStacktrace);
    }

    /**
     * Creates a JSON Layout using the default settings. Useful for testing.
     *
     * @return A JSON Layout.
     */
    public static LogJsonLayout createDefaultLayout() {
        return new LogJsonLayout(new DefaultConfiguration(), false, false, false, false, false, false,
                DEFAULT_HEADER, DEFAULT_FOOTER, StandardCharsets.UTF_8, APP_NAME,ENV,true);
    }

    @Override
    public void toSerializable(final LogEvent event, final Writer writer) throws IOException {
        super.toSerializable(event, writer);
    }
}



import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;

public class LocalIP {
        public static InetAddress getIpAddress() throws SocketException {
            Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces();
            while (interfaces.hasMoreElements()) {
                NetworkInterface current = interfaces.nextElement();
                if (!current.isUp() || current.isLoopback() || current.isVirtual())
                    continue;
                Enumeration<InetAddress> addresses = current.getInetAddresses();
                while (addresses.hasMoreElements()) {
                    InetAddress addr = addresses.nextElement();
                    if (addr.isLoopbackAddress())
                        continue;
                    if (addr.isSiteLocalAddress()) {//去掉还回和虚拟地址  
                        return addr;
                    }
                    //              System.out.println(addr.isSiteLocalAddress());  
                    //              System.out.println(addr);  
                }
            }

            throw new SocketException("Can't get our ip address, interfaces are: " + interfaces);
        }

    }```
```java

import com.fasterxml.jackson.core.PrettyPrinter;
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
import com.fasterxml.jackson.core.util.MinimalPrettyPrinter;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.ObjectWriter;
import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import org.apache.logging.log4j.core.impl.Log4jLogEvent;
import org.apache.logging.log4j.core.jackson.JsonConstants;
import org.apache.logging.log4j.core.jackson.Log4jJsonObjectMapper;

import java.util.HashSet;
import java.util.Set;

abstract class JacksonFactory {

    static class JSON extends JacksonFactory {

        private final boolean encodeThreadContextAsList;
        private final boolean includeStacktrace;

        public JSON(final boolean encodeThreadContextAsList, final boolean includeStacktrace) {
            this.encodeThreadContextAsList = encodeThreadContextAsList;
            this.includeStacktrace = includeStacktrace;
        }

        @Override
        protected String getPropertNameForContextMap() {
            return JsonConstants.ELT_CONTEXT_MAP;
        }

        @Override
        protected String getPropertNameForSource() {
            return JsonConstants.ELT_SOURCE;
        }

        @Override
        protected String getPropertNameForNanoTime() {
            return JsonConstants.ELT_NANO_TIME;
        }

        @Override
        protected PrettyPrinter newCompactPrinter() {
            return new MinimalPrettyPrinter();
        }

        @Override
        protected ObjectMapper newObjectMapper() {
            return new Log4jJsonObjectMapper();
        }

        @Override
        protected PrettyPrinter newPrettyPrinter() {
            return new DefaultPrettyPrinter();
        }
    }


    abstract protected String getPropertNameForContextMap();

    abstract protected String getPropertNameForSource();

    abstract protected String getPropertNameForNanoTime();

    abstract protected PrettyPrinter newCompactPrinter();

    abstract protected ObjectMapper newObjectMapper();

    abstract protected PrettyPrinter newPrettyPrinter();

    ObjectWriter newWriter(final boolean locationInfo, final boolean properties, final boolean compact) {
        final SimpleFilterProvider filters = new SimpleFilterProvider();
        final Set<String> except = new HashSet<>(2);
        if (!locationInfo) {
            except.add(this.getPropertNameForSource());
        }
        if (!properties) {
            except.add(this.getPropertNameForContextMap());
        }
        except.add(this.getPropertNameForNanoTime());
        filters.addFilter(Log4jLogEvent.class.getName(), SimpleBeanPropertyFilter.serializeAllExcept(except));
        final ObjectWriter writer = this.newObjectMapper().writer(compact ? this.newCompactPrinter() : this.newPrettyPrinter());
        return writer.with(filters);
    }

}



package com.imile.ucenter.web.log4j2;

import cn.hutool.core.date.DateUtil;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectWriter;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.layout.AbstractStringLayout;
import org.apache.logging.log4j.core.util.StringBuilderWriter;
import org.apache.logging.log4j.util.Strings;

import java.io.IOException;
import java.io.Writer;
import java.nio.charset.Charset;


abstract class AbstractJacksonLayout extends AbstractStringLayout {

    protected static final String DEFAULT_EOL = "\r\n";
    protected static final String COMPACT_EOL = Strings.EMPTY;

    protected final String eol;

    protected final String appName;
    protected final String env;
    protected final ObjectWriter objectWriter;
    protected final boolean compact;
    protected final boolean complete;

    protected AbstractJacksonLayout(final Configuration config, final ObjectWriter objectWriter, final Charset charset,final String appName,String env,
                                    final boolean compact, final boolean complete, final boolean eventEol, final Serializer headerSerializer,
                                    final Serializer footerSerializer) {
        super(config, charset, headerSerializer, footerSerializer);
        this.objectWriter = objectWriter;
        this.compact = compact;
        this.complete = complete;
        this.eol = compact && !eventEol ? COMPACT_EOL : DEFAULT_EOL;
        this.appName = appName;
        this.env = env;
    }


    @Override
    public String toSerializable(final LogEvent event) {
        final StringBuilderWriter writer = new StringBuilderWriter();
        try {
            toSerializable(event, writer);
            //这里插入skywalking的traceId
            writer.getBuilder().insert(1, "\"time\": \"" + DateUtil.now() +"\",");
            writer.getBuilder().insert(1,"\"appName\": \"" + appName +"\",");
            writer.getBuilder().insert(1,"\"ip\": \"" + LocalIP.getIpAddress().getHostAddress() +"\",");
            writer.getBuilder().insert(1,"\"env\": \"" + env +"\",");
            return writer.toString();
        } catch (final IOException e) {
            // Should this be an ISE or IAE?
            LOGGER.error(e);
            return Strings.EMPTY;
        }
    }

    private static LogEvent convertMutableToLog4jEvent(final LogEvent event) {
        // TODO Jackson-based layouts have certain filters set up for Log4jLogEvent.
        // TODO Need to set up the same filters for MutableLogEvent but don't know how...
        // This is a workaround.
        return event;
    }

    public void toSerializable(final LogEvent event, final Writer writer)
            throws JsonGenerationException, JsonMappingException, IOException {
        objectWriter.writeValue(writer, convertMutableToLog4jEvent(event));
        writer.write(eol);
        markEvent();
    }

}

主要难点主要是对老的业务框架的修改（各种排jar包冲突），这里是日志处修改，后续开发侧方案和流程待续。。。。。。。。。

pigcsy
关注
4.IDEA配置log4j2实现输出SQL语句
小曹同学的博客
04-11 1624
4.IDEA配置log4j2实现输出SQL语句 一、在pom.xml文件中导入log4j2的依赖 <!-- log4j2日志 --> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-web</artifactId> <version
Slf4j + Log4j2 + Mongodb 日志收集
u011420410的博客
09-11 876
slf4j + Log4j2 + mongodb springboot 日志收集 添加项目依赖 项目是基于　springboot 2.0+进行的，　在低版本没有测试过 pom.xml slf4j log4j依赖添加 <!-- log out --> <dependency> <groupId>org.slf4j&...
星巴克项目——ClickHouse集群和ELK的管理开发工程师
最新发布
H99800的博客
07-22 367
我们正在寻找一位熟悉ClickHouse和ELK的管理开发工程师，负责维护和管理我们的ClickHouse集群和ELK平台。作为日志平台管理开发工程师，您将负责确保ClickHouse集群，logstash, kafka集群，ES集群的高可用性、性能和安全性，可独立解决日志平台所有组件的故障和技术问题。关注行业动态，参与技术社区，不断学习和掌握新的技术和工具，为系统的稳定性和性能提供持续改进。- 设计和实施日志平台平台的备份和恢复策略，确保数据的安全性和可靠性。- 熟悉数据库管理和SQL语言。
Druid搭配log4j2输出SQL语句和结果
weixin_33804582的博客
03-20 1442
一、引言其实Druid的内置了log4jdbc来显示SQL语句，虽然显示效果不如原生的log4jdbc效果好，但是因为内置所以不需要其他更多的配置。二、使用1. 创建基于druid的logger &lt;bean id="log-filter" class="com.alibaba.druid.filter.logging.Slf4jLogFilter"&gt; &lt;pro...
springboot日志集成(1)：Logback & log4j2
weixin_46822085的博客
10-29 569
前言： java有许多的日志组件，比如 log4j,log4j2,logback还有java自生提供的Java Util Logging，其实在springboot中对这些组件都提供了支持，log4j，log4j2和logback都提供相应的组件支持。 一、Logback 1）在springboot中默认使用的日志工具是logback,不过在提及具体的日志工具之前要提一个名词，这个名词就是slf4j(Simple Logging Facade For Java)。 2）百度百科解释： https://.
Springboot整合之logback，log4j2
Jay的博客
07-25 585
Java 有很多日志系统，例如，Java Util Logging, Log4J, Log4J2, Logback 等。Spring Boot 也提供了不同的选项，比如日志框架可以用 logback 或 log4j 等。 默认的日志框架 logback 例如，maven 依赖中添加了 spring-boot-starter-logging。 <dependency> <groupId>org.springframework.boot</groupId> &
替代ELK：ClickHouse+Kafka+FlieBeat才是最绝的
Java_zhujia的博客
10-30 425
文件目录：/etc/filebeat/filebeat.yml filebeat.inputs: - type: log enabled: true paths: - /root/logs/xxx/inner/*.log json: 如果不设置该索性，所有的数据都存储在message里面，这样设置以后数据会平铺。--分布式表配置-->
ELK+Filebeat+Kafka+ZooKeeper构建日志分析平台
01-23
ELK+Filebeat+Kafka+ZooKeeper构建日志分析平台，架构图解
linux平台centos7系统 - ELK+logback+kafka+nginx 搭建分布式日志分析平台.doc
03-23
【Linux平台CentOS7系统 - ELK+logback+kafka+nginx搭建分布式日志分析平台】 在复杂的IT环境中，日志管理和分析对于诊断问题、优化性能以及确保系统稳定性至关重要。ELK栈（Elasticsearch、Logstash、Kibana）正是...
「从ES到CK 05」clickhouse高效数据处理工具vector
Pong_Kaho的博客
12-29 1760
clickhouse的高效数据处理工具、替代logstash的神器：vector
ELK 搭建日志分析系统 + Zipkin服务链路追踪整合
gmHappy
01-06 1661
一、需求描述 在分布式系统中，日志跟踪是一件很令程序员头疼的问题，在遇到生产问题时，如果是多节点需要打开多节点服务器去跟踪问题，如果下游也是多节点且调用多个服务，那就更麻烦，再者，如果没有分布式链路，在生产日志飞速滑动的情况下，很难找出问题。 所以，分布式系统中很有必要搭建一套分布式日志系统，笔者采用了市面成熟的解决方案ELK+Zipkin解决 二、组件依赖 利用ELK 搭建日志分析系统（一）—— 组件介绍 利用ELK 搭建日志分析系统（二）—— 部署安装 利用ELK 搭建日志分析系统（三）—— 安全认证
slf4j完整日志文件
04-25
基于slf4j的完整资源
spring mvc + mybatis + LOG4J2 打印SQL语句
xinjirufen1的专栏
08-12 6132
项目框架：maven+spring mvc + mybatis + log4j2，想在框架中增加log4j自动输出sql语句功能。借鉴了http://blog.csdn.net/rangqiwei/article/details/50825090方法。 步骤 1、resource文件夹下增加mybatis-config.xml文件，内容如下： <!DOCTYPE configurati
使用Log4j2打印Mybatis SQL语句以及结果集
hgffhh的博客
01-25 4575
使用Log4j2打印Mybatis SQL语句以及结果集
SpringBoot配置log4j2，将MyBatis日志打印到log4j2中
LX_vct的专栏
08-03 4347
近期需要做一个小的服务，最后决定使用SpringBoot框架做，期间遇到了一些坑，现在总结一下，以防后续踩坑。 本人使用的SpringBoot版本是2.5.3，对应的log4j2的版本是2.2.5，MyBatis使用的是SpringBoot自带的依赖：版本2.0.0 引入依赖，记得移除SpringBoot自带的logging； <dependency> <groupId>org.springframework.boot</g...
log4j2打印sql语句
ganjiee0007的博客
04-06 1117
log4j2-spring.xml文件中需要添加。spring+log4j+mybatis配置日志。
log4J2和logback冲突和共存解决方法
qq_21588061的博客
04-12 1709
一个在线编辑器调试打印日志功能，需要提供logback和log4j2不同日志框架的日志功能供使用方自由选择。
解决log4j2与logback冲突问题
m0_47743175的博客
09-26 1741
解决log4j2与logback冲突问题，spring-boot-starter-web 与spring-boot-starter-log4j2依赖冲突
MyBatis学习总结（六）---使用log4j2将sql语句执行记录输出控制台和文件中
qq_40348465的博客
11-29 6169
  在上一篇博客中我简单的介绍了在MyBatis中如何使用日志，并给出了一个在MyBatis中使用log4j的示例。    MyBatis中日志的使用及使用log4j示例   下面介绍在MyBatis中如何使用log4j2将sql语句执行记录输出控制台和文件中。   1.示例项目目录：        2.先导入log4j2所需要的两个jar包，如：log4j-api-2.11.1.jar...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值