精华内容
下载资源
问答
  • 日志聚合与关联分析技术实例视频演示 目前在企业网中,网络安全问题高度关联,因此系统易受攻击的程度往往取决于整个网络的多个漏洞,攻击者可以综合利用...来处理来自各方的安全相关信息处理问题),来解决单...

    日志聚合与关联分析技术实例视频演示


           目前在企业网中,网络安全问题高度关联,因此系统易受攻击的程度往往取决于整个网络的多个漏洞,攻击者可以综合利用这些漏洞,逐步渗透网络并破坏、威胁到关键系统,但做为管理员的你,或许还浑然不觉,这时或许你还在抱着一些传统的安全工具(因为它们缺乏一个统一的框架,来处理来自各方的安全相关信息的处理问题),来解决单一问题,看不见全局变化,又怎么能发现攻击中在综合利用漏洞发起网络攻击呢?不过话又说回来,即使你是一个经验丰富的安全分析师,也难以综合多个源(例如十多个、甚至几十个)的结果来分析复杂的多步攻击能利用的漏洞。要解决这个问题,你该怎么办?

          各种网络应用日志如何预处理变成事件,各类事件又是如何经过聚合进行关联分析的技术已在《开源安全运维平台OSSIM最佳实践》一书进行了详尽的分析,下面就给大家展示,在大数据IDS机房环境中如何在海量日志中,快速定位SSH暴力破解攻击源,让你看得见网络攻击。


    高清视频地址:


    http://www.tudou.com/programs/view/uP0V9fQlzuo 

     

    下图展示了几张OSSIM中灵活的规则和策略管理界面

    wKiom1aDOg6CuCKEAANk7SBOcao420.jpg

     wKiom1aDOljSBHL1AALDMcjw2Ts960.jpg

    wKioL1aDOoeyuPIrAARmcHZAXZo206.jpg

    看过之后,感觉如何?ELK、Splunk系统能实现吗?这里我只是举了SSH的例子,可类似这种可视化分析方法在OSSIM中还有上千种类型,有兴趣的朋友可以阅读《OSSIM让网络攻击无所遁形》以深入了解。





     本文转自 李晨光 51CTO博客,原文链接:http://blog.51cto.com/chenguang/1728514,如需转载请自行联系原作者


    展开全文
  • 随着微服务等设计理念在系统中的应用,业务的调用链越来越复杂,日志信息越来越大,从快速增长的日志数据流中提取出所需的信息,并将其与其他相关联的事件进行关联,将变得越加困难.ELK + KAFKA作为微服务应用日志...

    微服务应用日志组件定制

    随着微服务等设计理念在系统中的应用,业务的调用链越来越复杂,日志信息越来越大,从快速增长的日志数据流中提取出所需的信息,并将其与其他相关联的事件进行关联,将变得越加困难.ELK + KAFKA作为微服务应用日志中心解决方案是业界常规办法,前提是应用日志输出的规范化,日志组件就是为了完成这一目标。

    微服务应用日志格式规划

    经过公司技术人员充分讨论和分析,确认了应用日志输出格式如下:

    |时间|日志级别|线程名|代码发生行|同步调用ID|客户系统节点|服务系统节点|客户系统名称|服务系统名称|日志类型|全局流水号|定制化字段^日志信息|
    
    • 时间:记录日志产生时间;
    • 日志级别:致命,ERROR,WARN,INFO,DEBUG;
    • 线程名:执行操作线程名称;
    • 代码发生行:日志事件发生在代码中位置;
    • 同步调用ID:用于同步调用链分析,可以关联基普金,精确定位等工具关联排查问题;
    • 客户系统节点:表示服务 - 客户端系统节点的标识,可以为IP或者DockerID;
    • 服务系统节点:表示服务 - 服务端系统节点的标识,可以为IP或者DockerID;
    • 客户系统名称:表示服务 - 客户端系统的标识,可以为系统简称和全称;
    • 服务系统名称:表示服务 - 服务端系统的标识,可以为系统简称和全称;
    • 全局流水号:贯穿一次业务流程的全局流水号;
    • 日志类型:枚举,REQ-接口请求报文,RESP-接口响应报文,BIZ-通用日志;
    • INFO:定制化字段(格式采用关键字段=值,关键字段2 =值)^业务信息(记录详细日志信息)。

    举个栗子:

    |2018-03-28 14:26:21.001|INFO|demo-service-woker:share-d-3[share]-thread-1|com.xxxx.xxx.service.interceptor.ParamCheckInterceptor:59:doInvoke|4507080825331412517041832|127.0.0.1:50344|127.0.0.1:20015|demo-a|demo-b|20170428142618325183APP|BIZ|phoneNumber=185****1234, woAccountId=110000008592138^参数及权限校验拦截,验证通过.|
    

    日志组件实现方案

    Java的技术平台日志输出组件主要有java.util.logging中,log4j的,log4j2,的logback,SLF4J。我司目前使用的log4j2 + SLF4J组合作为应用日志输出组件,为了实现上述日志格式输出,主要有两种方式在组件上实现封装,应用采用SpringBoot +宁静作为主框架

    Log4J的的MDC方案

    MDC [ http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/MDC.html]是为每个线程建立一个独立的存储空间,开发人员可以根据需要把信息存入其中.MDC使用Map机制来存储信息,信息以键/值对的形式存储在Map中。
    使用Servlet过滤器或者AOP在服务接收到请求时,获取需要的值填充MDC。在log4j2的配置中就可以使用% X {}键MDC打印中的内容,从而识别出同一次请求中的日志。

    Log4j2.X版本
    MdcLogfilter类
    public class MdcLogfilter implements Filter {
    
        public static final String TRACE_ID = "traceId";
    
        public static final String CLIENT_ADDR = "clientAddr";
    
        public static final String SERVER_ADDR = "serverAddr";
    
        public static final String CLIENT_SYS_NAME = "clientSysName";
    
        public static final String SERVER_SYS_NAME = "serverSysName";
    
        public static final String TRANS_ID = "transId";
    
        public static final String LOG_TYPE = LogTypeEnum.BIZ.getKey();
    
        private String systemName;
    
        public MdcLogfilter( String systemName ) {
            this.systemName = systemName;
        }
    
        @Override
        public void init( FilterConfig filterConfig ) throws ServletException {
        }
    
        @Override
        public void doFilter( ServletRequest request, ServletResponse response, FilterChain chain ) throws IOException, ServletException {
            try {
                insertIntoMDC(request);
                chain.doFilter(request, response);
            } finally {
                ThreadContext.clearAll();
            }
        }
    
        @Override
        public void destroy() {
        }
    
        protected void insertIntoMDC( ServletRequest request ) {
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            String traceId = httpRequest.getHeader(TRACE_ID);
            String clientAddr = httpRequest.getRemoteAddr();
            String serverAddr = getSreverAddr();
            String clientSysName = httpRequest.getHeader(CLIENT_SYS_NAME);
            String serverSysName = systemName;
            String transId = (String) httpRequest.getAttribute(TRANS_ID);
            ThreadContext.put(TRACE_ID, traceId);
            ThreadContext.put(CLIENT_ADDR, clientAddr);
            ThreadContext.put(SERVER_ADDR, serverAddr);
            ThreadContext.put(CLIENT_SYS_NAME, clientSysName);
            ThreadContext.put(SERVER_SYS_NAME, serverSysName);
            ThreadContext.put(TRANS_ID, transId);
            ThreadContext.put(LOG_TYPE, LogTypeEnum.REQ.getKey());
        }
    
        private String getServerAddr() {
            return null;
        }
    
    }
    
    
    MDCLogAspect类
    @Aspect
    public class MDCLogAspect {
    
        private static final Logger LOGGER = LoggerFactory.getLogger(EpayLogAspect.class);
    
        private static long STIME = LogUtil.getNowTimeInMillis();
    
        private static String REQUESTURL = "url";
    
        @Pointcut("execution(public * com.demo..*.*.controller.*.*(..))")
        public void log() {
        }
    
        @Before("log()")
        public void deBefore( JoinPoint joinPoint ) throws Throwable {
            STIME = LogUtil.getNowTimeInMillis();
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            Map<String, String[]> params = request.getParameterMap();
            String queryString = "";
            for (String key : params.keySet()) {
                String[] values = params.get(key);
                for (int i = 0; i < values.length; i++) {
                    String value = values[i];
                    queryString += key + "=" + value + "&";
                }
            }
            
            if (!StringUtils.isEmpty(queryString)){
                queryString = queryString.substring(0, queryString.length() - 1);
            }
            REQUESTURL = request.getRequestURL().toString();
    
            LOGGER.info("url:{},req:{}", REQUESTURL, queryString);
            MDC.put(LogPreKeyConstants.LOGTYPE, LogTypeEnum.BIZ.getKey());
        }
    
        @AfterReturning(returning = "ret", pointcut = "log()")
        public void doAfterReturning( Object ret ) throws Throwable {
            MDC.put(LogPreKeyConstants.LOGTYPE, LogTypeEnum.RESP.getKey());
            LOGGER.info("url:{},resp:{}", REQUESTURL, ret);
            MDC.remove(LogPreKeyConstants.LOGTYPE);
            MDC.put(LogPreKeyConstants.LOGTYPE, LogTypeEnum.BIZ.getKey());
        }
    
        //后置异常通知
        @AfterThrowing("log()")
        public void throwss( JoinPoint jp ) {
            String costtime = LogUtil.getNowTimeInMillis() - STIME + "ms";
            LOGGER.info("url:{},executetime:{}", REQUESTURL, costtime);
        }
    
        //后置最终通知,final增强,不管是抛出异常或者正常退出都会执行
        @After("log()")
        public void after( JoinPoint jp ) {
            String costtime = LogUtil.getNowTimeInMillis() - STIME + "ms";
            LOGGER.info("url:{},executetime:{}", REQUESTURL, costtime);
        }
    }
    
    
    Log4j1.X版本

    log4j1.x版本,ThreadContext类换成MDC即可

    log4j的配置使用MDC

    在log4j配置中,使用mdc:(log4j 1.x与2.x中都可以使用此配置)

    <PatternLayout pattern="|%d{yyyy-MM-dd HH:mm:ss.SSS}|%5p|%5t|%4c:%L|%X{traceid}|%X{clientaddr}|%X{serveraddr}|%X{cientsysname}|%X{serversysname}|%X{transid}|%X{logType}|%m|%n" />
    
    Springboot使用

    实现定制化登录开始,应用依赖即可。

    Log4J的的适配器封装方案

    使用适配器模式封装log4j的接口,使用AOP在服务接收到请求时,获取需要的值填充本地线程副本中,打印日志时候拼接输出到日志。

    Log4j2.X / Log4j1.X版本
    LogContextHolder
    public class AdapterLogContextHolder {
    
        private static final ThreadLocal<AdapterLogContext> LOG_CONTEXT = new ThreadLocal<>();
    
        private static AdapterLogContextHolder context = new AdapterLogContextHolder();
    
        private AdapterLogContextHolder() {
        }
    
        public static AdapterLogContextHolder getInstance() {
            return context;
        }
    
        public AdapterLogContext getLogContext() {
            AdapterLogContext context = LOG_CONTEXT.get();
    
            if (context == null) {
                context = new AdapterLogContext();
                LOG_CONTEXT.set(context);
            }
            return context;
        }
    
        public void setLogContext( AdapterLogContext context ) {
            LOG_CONTEXT.set(context);
        }
    
        public void removeLogContext() {
            LOG_CONTEXT.remove();
        }
    
        public String getTraceID() {
            return getLogContext().getTraceID();
        }
    
        public void setTraceID( String id ) {
            getLogContext().setTraceID(id);
        }
    }
    
    
    
    AdapterLogContext
    public class AdapterLogContext implements Serializable, Cloneable {
    
        private static final long serialVersionUID = 6126191683350551062L;
    
        private String traceID = "traceID";
    
        private long callStartTimes;
    
        private String transID = "transId";
    
        private String clientAddr = "clientAddr";
    
        private String serverAddr = "serverAddr";
    
        private String clientSysName = "clientSysName";
    
        private String serverSysName = "serverSysName";
    
        @Override
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
        //get、set .....
    }
    
    LoggerAdapter
    public class LoggerAdapter {
    
        final static String FQCN = LoggerAdapter.class.getName();
    
        private static LoggerAdapter loggerAdapter;
    
        private static volatile HashMap<String, LoggerAdapter> loggerxMap = null;
    
        protected Logger logger = null;
    
        private LoggerAdapter( Logger logger ) {
            this.logger = logger;
        }
    
        public static LoggerAdapter getLogger( Class<?> classObject ) {
    
            if (null == classObject) {
                throw new IllegalArgumentException();
            }
    
            if (loggerxMap == null) {
                synchronized (Loggerx.class) {
                    if (loggerxMap == null) {
                        loggerxMap = new HashMap<>();
                        return getLoggerAdapter(classObject);
                    }
                }
            }
    
            LoggerAdapter loggerAdapter = loggerxMap.get(classObject.getSimpleName());
            if (loggerAdapter == null) {
                return getLoggerAdapter(classObject);
            } else {
                return loggerAdapter;
            }
        }
    
        private static LoggerAdapter getLoggerAdapter( Class<?> classObject ) {
            Logger logger = LogManager.getLogger(classObject);
            if (logger == null) {
                return null;
            }
    
            LoggerAdapter loggerAdapter = new LoggerAdapter(logger);
            loggerxMap.put(classObject.getSimpleName(), loggerAdapter);
    
            return loggerAdapter;
        }
    
        public void info( LogType logType, Object message ) {
            String msgFormatted = msgFormat(logType, message);
            logger.log(FQCN, Level.INFO, msgFormatted, null);
        }
    
        public void info( LogType logType, Map<String, String> custMsg, Object message ) {
            String msgFormatted = msgFormat(logType, custMsg, message);
            logger.log(FQCN, Level.INFO, msgFormatted, null);
        }
    
        public void error( LogType logType, Object message ) {
            String msgFormatted = msgFormat(logType, message);
            logger.log(FQCN, Level.ERROR, msgFormatted, null);
        }
    
        public void error( LogType logType, Map<String, String> custMsg, Object message ) {
            String msgFormatted = msgFormat(logType, custMsg, message);
            logger.log(FQCN, Level.ERROR, msgFormatted, null);
        }
    
        public void error( LogType logType, Object message, Throwable t ) {
            String msgFormatted = msgFormat(logType, message);
            logger.log(FQCN, Level.ERROR, msgFormatted, t);
        }
    
        public void error( LogType logType, Map<String, String> custMsg, Object message, Throwable t ) {
            String msgFormatted = msgFormat(logType, custMsg, message);
            logger.log(FQCN, Level.ERROR, msgFormatted, t);
        }
    
        public void warn( LogType logType, Object message ) {
            String msgFormatted = msgFormat(logType, message);
            logger.log(FQCN, Level.WARN, msgFormatted, null);
        }
    
        public void warn( LogType logType, Map<String, String> custMsg, Object message ) {
            String msgFormatted = msgFormat(logType, custMsg, message);
            logger.log(FQCN, Level.WARN, msgFormatted, null);
        }
    
        public void debug( LogType logType, Object message ) {
            String msgFormatted = msgFormat(logType, message);
            logger.log(FQCN, Level.DEBUG, msgFormatted, null);
        }
    
        protected String msgFormat( LogType logType, Object message ) {
            StringBuilder sb = new StringBuilder();
            AdapterLogContext logContext = AdapterLogContextHolder.getInstance().getLogContext();
            sb.append(logContext.getTraceID());
            sb.append("|").append(logContext.getClientAddr());
            sb.append("|").append(logContext.getServerAddr());
            sb.append("|").append(logContext.getClientSysName());
            sb.append("|").append(logContext.getServerAddr());
            sb.append("|").append(logContext.getTransID());
            sb.append("|").append(logType);
            sb.append("|").append("custmsg=null");
            sb.append(message != null ? "^" + message.toString().replaceAll("\r|\n", "").replaceAll("\\|", "#") + "|" : "");
            return sb.toString();
        }
    
        protected String msgFormat( LogType logType, Map<String, String> custMsgMap, Object message ) {
            if (custMsgMap == null || custMsgMap.isEmpty()) {
                return msgFormat(logType, message);
            } else {
                StringBuilder sb = new StringBuilder();
                AdapterLogContext logContext = AdapterLogContextHolder.getInstance().getLogContext();
                sb.append("|").append(logContext.getClientAddr());
                sb.append("|").append(logContext.getServerAddr());
                sb.append("|").append(logContext.getClientSysName());
                sb.append("|").append(logContext.getServerAddr());
                sb.append("|").append(logContext.getTransID());
                sb.append("|").append(logType);
                sb.append("|");
                for (Map.Entry<String, String> entry : custMsgMap.entrySet()) {
                    sb.append(entry.getKey() + "=" + entry.getValue() + ",");
                }
                sb.deleteCharAt(sb.length() - 1);
                sb.append(message != null ? "^" + message.toString().replaceAll("\r|\n", "") + "|" : "");
                return sb.toString();
            }
        }
    }
    
    
    AOP切片类LoggerAdapter
    public class ClientContextBeforeAdvice implements MethodBeforeAdvice {
    
        @Override
        public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
            try {
                if (arg1.length == 0 || !(arg1[0] instanceof BaseRequest)) {
                    return;
                }
    
                AdapterLogContext logContext = AdapterLogContextHolder.getInstance().getLogContext()
    
                //获取logContext各个属性值
                BaseRequest request = (BaseRequest) arg1[0];
                request.setLogContext(logContext);
            } catch (Exception e) {
                LOGGER.error(LogType.EX, "", e);
                throw e;
            }
        }
    }
    
    //其他AOP切片
    
    log4j的配置使用适配器模式

    在log4j配置中,log4j 1.x与2.x中都可以使用正常配置

    Springboot使用

    实现定制化登录开始,应用依赖即可。

    MDC方式与适配器方式对比

    两种对比,MDC优点在于不改变开发人员使用的log4j方法,引入不需要更改业务代码,适配器优势在于使用AOP和ThreadLocal的方式更方便定制化。我司目前使用MDC方案。



    转载于:https://www.cnblogs.com/airen123/p/10609004.html

    展开全文
  • 12,tomcat日志处理

    2012-11-13 13:15:38
    日志系统是一个记录信息的组件。在Catalina中,日志系统是一个相对简单的跟容器相关联的组件。Tomcat在org.apache.catalina.logger包中提供了多个不同的日志系统Logger接口一个日志系统必须实现org.apache.catalina....

    日志系统是一个记录信息的组件。在Catalina中,日志系统是一个相对简单的跟容器相关联的组件。
    Tomcat在org.apache.catalina.logger包中提供了多个不同的日志系统
    Logger接口
    一个日志系统必须实现org.apache.catalina.Logger接口

     

    public interface Logger {
    
    
        // ----------------------------------------------------- Manifest Constants
    
    
        /**
         * Verbosity level constants for log messages that may be filtered
         * by the underlying logger.
         */
    
        public static final int FATAL = Integer.MIN_VALUE;
    
        public static final int ERROR = 1;
    
        public static final int WARNING = 2;
    
        public static final int INFORMATION = 3;
    
        public static final int DEBUG = 4;
    
    
        // ------------------------------------------------------------- Properties
    
    
        /**
         * Return the Container with which this Logger has been associated.
         */
        public Container getContainer();
    
    
        /**
         * Set the Container with which this Logger has been associated.
         *
         * @param container The associated Container
         */
        public void setContainer(Container container);
    
    
        /**
         * Return descriptive information about this Logger implementation and
         * the corresponding version number, in the format
         * <code>&lt;description&gt;/&lt;version&gt;</code>.
         */
        public String getInfo();
    
    
        /**
         * Return the verbosity level of this logger.  Messages logged with a
         * higher verbosity than this level will be silently ignored.
         */
        public int getVerbosity();
    
    
        /**
         * Set the verbosity level of this logger.  Messages logged with a
         * higher verbosity than this level will be silently ignored.
         *
         * @param verbosity The new verbosity level
         */
        public void setVerbosity(int verbosity);
    
    
        // --------------------------------------------------------- Public Methods
    
    
        /**
         * Add a property change listener to this component.
         *
         * @param listener The listener to add
         */
        public void addPropertyChangeListener(PropertyChangeListener listener);
    
    
        /**
         * Writes the specified message to a servlet log file, usually an event
         * log.  The name and type of the servlet log is specific to the
         * servlet container.  This message will be logged unconditionally.
         *
         * @param message A <code>String</code> specifying the message to be
         *  written to the log file
         */
        public void log(String message);
    
    
        /**
         * Writes the specified exception, and message, to a servlet log file.
         * The implementation of this method should call
         * <code>log(msg, exception)</code> instead.  This method is deprecated
         * in the ServletContext interface, but not deprecated here to avoid
         * many useless compiler warnings.  This message will be logged
         * unconditionally.
         *
         * @param exception An <code>Exception</code> to be reported
         * @param msg The associated message string
         */
        public void log(Exception exception, String msg);
    
    
        /**
         * Writes an explanatory message and a stack trace for a given
         * <code>Throwable</code> exception to the servlet log file.  The name
         * and type of the servlet log file is specific to the servlet container,
         * usually an event log.  This message will be logged unconditionally.
         *
         * @param message A <code>String</code> that describes the error or
         *  exception
         * @param throwable The <code>Throwable</code> error or exception
         */
        public void log(String message, Throwable throwable);
    
    
        /**
         * Writes the specified message to the servlet log file, usually an event
         * log, if the logger is set to a verbosity level equal to or higher than
         * the specified value for this message.
         *
         * @param message A <code>String</code> specifying the message to be
         *  written to the log file
         * @param verbosity Verbosity level of this message
         */
        public void log(String message, int verbosity);
    
    
        /**
         * Writes the specified message and exception to the servlet log file,
         * usually an event log, if the logger is set to a verbosity level equal
         * to or higher than the specified value for this message.
         *
         * @param message A <code>String</code> that describes the error or
         *  exception
         * @param throwable The <code>Throwable</code> error or exception
         * @param verbosity Verbosity level of this message
         */
        public void log(String message, Throwable throwable, int verbosity);
    
    
        /**
         * Remove a property change listener from this component.
         *
         * @param listener The listener to remove
         */
        public void removePropertyChangeListener(PropertyChangeListener listener);
    
    
    }

     日志接口提供了日志系统要实现的方法,最简单的方法是接受一个字符串并将其记录,
    最后两个方法会接受一个冗余级别(verbosity level),如果传递的数字低于该类的实例设置的冗余级别,就将信息记录下来,否则就忽略信息。
    静态变量定义了五个冗余级别:FATAL, ERROR, WARNING, INFORMATION,和 DEBUG。getVerbosity和setVerbosity分别用来获得和设置冗余级别。
    日志接口还有getContainer 和 setContainer方法用来将日志系统跟容器关联起来

    Tomcat日志系统
    Tomcat提供了三种日志系统,它们分别是FileLogger, SystemErrLogger, 和 SystemOutLogger。
    都继承了org.apache.catalina.logger.LoggerBase类

     



     

     

     

    LoggerBase类
    LoggerBase类是一个抽象类,它实现了Logger接口中除log(String msg)之外的所有方法。
     public abstract void log(String msg);
    该方法需要在子类进行覆盖(overload),所有的其他的log方法都调用了该方法
    SystemOutLogger类
    SystemOutLogger作为LoggerBase的子类提供了log(String message)方法的实现
    每一个收到的信息都被传递给System.out.println
    public class SystemOutLogger extends LoggerBase {
     protected static final String info = "org.apache.catalina.logger.SystemOutLogger/1.0";
     public void log(String msg) {
      System.out.println(msg);
     }
    }

    SystemErrLogger类
    public class SystemErrLogger extends LoggerBase {
     protected static final String info = "org.apache.catalina.logger.SystemErrLogger/1.0";
     public void log(String msg) {
      System.err.println(msg);
     }
    }

    FileLogger类
    FileLogger是LoggerBase类中最复杂的
    它将从关联容器收到的信息写到文件中,每个信息可以选择性的加上时间戳。
    在第一次实例化的时候,该类的实例会创建一个文件,该文件的名字带有日期信息。
    如果日期改变了,它会创建一个新的文件并把信息写在里面。

     

     

    public void log(String msg) {
    
            // Construct the timestamp we will use, if requested
            Timestamp ts = new Timestamp(System.currentTimeMillis());
            String tsString = ts.toString().substring(0, 19);
            String tsDate = tsString.substring(0, 10);
    
            // If the date has changed, switch log files
            if (!date.equals(tsDate)) {
                synchronized (this) {
                    if (!date.equals(tsDate)) {
                        close();
                        date = tsDate;
                        open();
                    }
                }
            }
    
            // Log this message, timestamped if necessary
            if (writer != null) {
                if (timestamp) {
                    writer.println(tsString + " " + msg);
                } else {
                    writer.println(msg);
                }
            }
    
        }

     log方法接受一个消息并把消息写到日志文件中。
    在FileLogger实例的生命周期中,log方法可以打开或关闭多个日志文件。
    写日志的方法

    private void open() {
    
            // Create the directory if necessary
            File dir = new File(directory);
            if (!dir.isAbsolute())
                dir = new File(System.getProperty("catalina.base"), directory);
            dir.mkdirs();
    
            // Open the current log file
            try {
                String pathname = dir.getAbsolutePath() + File.separator +
                    prefix + date + suffix;
                writer = new PrintWriter(new FileWriter(pathname, true), true);
            } catch (IOException e) {
                writer = null;
            }
    
        }

     

    open方法首先应该创建日志的目录是否存在,如果目录不存在,则首先创建目录
    Close方法清空PrintWriter变量writer,然后关闭PrintWriter并将writer设置为null
     private void close() {

            if (writer == null)
                return;
            writer.flush();
            writer.close();
            writer = null;
            date = "";

        }

    展开全文
  • 告警日志处理过程

    2008-07-21 17:23:17
    在告警相关性分析中, 告警处理主要处理步骤为: 1.资产配置,环境准备 2.采集 3.格式标准化 ...6.关联 ...从各种安全设备收集所有安全事件、告警、事故...为提供精确的事故处理,对高质量和低质量两种信息进行过滤的...
    在告警相关性分析中,
    告警处理主要处理步骤为:
    1.资产配置,环境准备
    2.采集
    3.格式标准化
    4.过滤
    5.分类
    6.关联
    7.展现

    归并
    从各种安全设备收集所有安全事件、告警、事故和日志的过程。
    正规化
    利用EVM的通用解码器同步和正规化巨量信息到单一可读格式的过程。
    过滤 [drools 推理引擎 ]
    为提供精确的事故处理,对高质量和低质量两种信息进行过滤的过程。.
    归类 [drools 推理引擎 2]
    为增加信息分析的有效性进行信息归类的过程。
    主关联引擎 1 和 2
    为进行精确决策和质量分析,从相关的安全设备关联和匹配信息的过程。
    人工智能[推理引擎 3]
    利用内置的近似人工智能的方法自动处理安全事故的过程。
    趋势分析
    依据日期、时间、攻击类型、源IP,目标IP,基于设备和事故的最高攻击范围,最低攻击范围等要素,进行自动的趋势分析的过程。
    动态数据分析, 报告和可视化
    从不同的维数进行分析以提供各种可输出的报告形式,如XML, PDF, Text, Excel 和HTML等格式。为提供精确的可视效果,生成客户化报告的过程。
    展开全文
  • 在互联网迅猛发展的今天 各大厂发挥十八般武艺的收集用户的各种信息,甚至包括点击的位置,我们也经常发现自己刚搜完一个东西,再打开网页时每个小广告都会出现与之相关联的商品或信息,在感叹智能的同时不惊想 什么...
  • 在互联网迅猛发展的今天 各大厂发挥十八般武艺的收集用户的各种信息,甚至包括点击的位置,我们也经常发现自己刚搜完一个东西,再打开网页时每个小广告都会出现与之相关联的商品或信息,在感叹智能的同时不惊想 什么...
  • 通过Flink去记录用户浏览过这个类目下的某些产品,为后面的基于项目的协同过滤做准备实时的记录用户的评分到Hbase中,为后续离线处理做准备。 数据存储在Hbase的p_history表 用户-兴趣->实现基于碱性的推荐逻辑 根据...
  • 如何记录日志

    2017-10-30 18:00:00
    如何确定日志的级别 日志的分类 ...将一个请求的整个处理流程和唯一的requestID关联起来 日志中该记录什么 [INFO] RequestID:b1946ac92492d2347c6235b4d2611184, ErrorCode:1426, Message: callb...
  • 但即使DataStage操作起来已经相当直观,且日志提示信息也已比较明了,但实际开发过程中仍然会遇到这样那样的问题。  为了提醒大家,特别是DataStage新手在学习实践过程中少走一些弯路。特根据本人在DataStage开发...
  • 摘要 在互联网的强力推进下,Web已成为信息制造、发布、处理和加工的主要平台。然而Web上承载的信息正在迅速膨胀,从而导致了一个严重的问题——“信息爆炸”,即信息极大丰富,而知识相对贫乏。正是在这种情况下,...
  • 管理员能够获取信息的主要来源是事件日志,PowerShell中有专门的Get-EventLog cmdlet处理事件日志。为了获取已存在的事件日志,需要使用-list参数以返回System.Diagnostics.EventLog类型的对象集合。获取这些对象后...
  • 经过规范化、过滤、归并和告警分析等处理后,以统一格式的日志形式进行集中存储和管理,结合丰富的日志统计汇总及关联分析功能,实现对信息系统日志的全面审计。 通过日志审计系统,企业管理员随时了解整个IT系统的...
  • 根据日志获取的特点,采用增量关联规则挖掘处理日志信息去除其噪声,利用协同滤波思想扩展图像标注词数量,利用WordNet得到标注词间关系,并结合图像底层特征利用混合概率模型实现图像自动标注。在Corel5K和互联网...
  • SECwin-简单事件关联器Windows集成。... 注意该项目已移至GITHUB,此处不会再发布任何版本。... -通过用户界面发送信号进行处理。... -SEC日志和转储实时视图窗口-SEC Perl进程统计信息-SEC和SECwin的自动更新
  • win7关于文件关联的问题

    千次阅读 2011-01-13 20:59:00
    今天又处理一起与win7文件关联相关的电脑故障,循例我又来写一篇日志。     在xp的年代,文件关联信息存在于注册表中的      HKEY_CLASSES_ROOT/.ext <br /> ...
  • 工作日志 2018/8/16

    2018-08-16 18:42:56
    同一业务有先后逻辑关系,不同业务有逻辑关联关系,多表情况下,主表记录删除(修改)后的连带关联表记录的处理出现问题。当删除警察信息时,与之关联的警察排班信息记录不会清除,而是显示null。 2.学习linux man ...
  • /etc/syslog.conf指定本守护进程可能收取的各种日志信息应该如何处理 这些消息可能被添加到一个文件(/dev/console文件是一个特例,它把消息写到控制台上),或者被写到指定用户的登录窗口(如果该用户已经登录到...
  • 在流式处理作业(特别是实时数仓ETL作业)中,我们的数据流可以视为无界事实表,其中往往缺乏一些维度信息。例如,对于埋点日志流而言,为了减少传输冗余,可能只会带有城市ID、商品ID等,如果要映射到对应的名称,...
  • Resque是Redis支持的库,... 日志信息会增加更多信息,并与工作人员,队列和作业ID(如果有)相关联。 创造就业机会 如果Resque_Job_Creator类存在并被Resque找到,则所有作业创建都将委派给该类。 注入此类的最佳方
  • 交易信息 商家余额 付款请求选项 数量 货币 语 预先授权 关联模型 拆分货币 原始数据 控制器 大事记 人际关系 交易关系 卡关系 楷模 交易模式 卡令牌模型 日志模型 被遗弃的交易 作者 安装 composer require ...
  • SSM05日志业务处理

    2020-10-13 20:17:57
    第1章 用户/角色/权限信息关联查询 1.1 查询用户实现的效果 通过查询用户,然后查看用户的角色信息,再查看用户的授权信息,效果如下: [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-...
  • MVC异常处理

    2015-05-18 14:45:00
    使用Nlog记录异常信息 首先引用NLog的dll文件,修改配置文件,在configuration下的configSections节点下,配置Nlog关联的配置节例如<section name="nlog" type="NLog.Config.ConfigSectionHandler, NLog" />...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 428
精华内容 171
关键字:

日志信息关联处理