精华内容
下载资源
问答
  • 日志管理系统

    万次阅读 2019-06-26 11:47:19
    为什么需要日志管理系统 保留现场 自知者自明 所有即将发生的,都取决于已经发生的 数据商业化运作 1.1 日志管理系统的解决方案 机器上的日志实时收集,存储到日志中心 给日志建立索引,通过索引能很快找到...

    一.为什么需要日志管理系统

    1. 保留现场
    2. 自知者自明
    3. 所有即将发生的,都取决于已经发生的
    4. 数据商业化运作

    1.1 日志管理系统的解决方案

    1. 机器上的日志实时收集,存储到日志中心
    2. 给日志建立索引,通过索引能很快找到日志
    3. 架设web界面,在web上完成日志的搜索

    1.2 日志管理系统的困难

    1. 日志量很大,每天几十亿条
    2. 日志的实时收集,延迟控制在分钟级别
    3. 能够在线水平扩展

    1.3 业内解决方案-ELK

         ELK 不是一款软件,而是 Elasticsearch、Logstash 和 Kibana 三种软件产品的首字母缩写:

    • Elasticsearch:分布式搜索和分析引擎,具有高可伸缩、高可靠和易管理等特点。基于 Apache Lucene 构建,能对大容量的数据进行接近实时的存储、搜索和分析操作。通常被用作某些应用的基础搜索引擎,使其具有复杂的搜索功能

    • Logstash:数据收集引擎。它支持动态的从各种数据源搜集数据,并对数据进行过滤、分析、丰富、统一格式等操作,然后存储到用户指定的位置

    • Kibana:数据分析和可视化平台。通常与 Elasticsearch 配合使用,对其中数据进行搜索、分析和以统计图表的方式展示

    1.3.1 简单ELK架构

          把一个 Logstash 数据搜集节点扩展到多个,分布于多台机器,将解析好的数据发送到 Elasticsearch server 进行存储,最后在 Kibana 查询、生成日志报表等 。

    1.3.2 引入消息队列的ELK架构

          使用 Logstash 从各个数据源搜集数据,然后经消息队列输出插件输出到消息队列中。目前 Logstash 支持 Kafka、Redis、RabbitMQ 等常见消息队列。然后 Logstash 通过消息队列输入插件从队列中获取数据,分析过滤后经输出插件发送到 Elasticsearch,最后通过 Kibana 展示。

    1.3.3 ELK方案的问题

    • 运维成本高,每增加一个日志收集,需要手动修改配置
    • 监控缺失,无法准确获取Logstash的状态二. 日志管理系统架构

    二. 日志收集系统架构

    2.1 组件介绍

    •  Log Agent:日志收集客户端,用来收集服务器上的日志
    •  Kafka:基于zookeeper协调的高吞吐量的分布式队列
    •  ES:elasticsearch,开源的分布式搜索引擎,给文档建立索引
    •  Hadoop:分布式计算框架,能够对大量数据进行分布式处理的平台

    2.2.1 日志采集工具介绍

                                                                Logstash

    优势:

           Logstash 主要的有点就是它的灵活性,主要因为它有很多插件,详细的文档以及直白的配置格式让它可以在多种场景下应用。我们基本上可以在网上找到很多资源,几乎可以处理任何问题。

    劣势:

            Logstash 致命的问题是它的性能以及资源消耗(默认的堆大小是 1GB)。尽管它的性能在近几年已经有很大提升,与它的替代者们相比还是要慢很多的。这里有 Logstash 与 rsyslog 性能对比以及Logstash 与 filebeat 的性能对比。它在大数据量的情况下会是个问题。另一个问题是它目前不支持缓存,目前的典型替代方案是将 Redis 或 Kafka 作为中心缓冲池:

    典型应用场景:

           因为 Logstash 自身的灵活性以及网络上丰富的资料,Logstash 适用于原型验证阶段使用,或者解析非常的复杂的时候。在不考虑服务器资源的情况下,如果服务器的性能足够好,我们也可以为每台服务器安装 Logstash 。我们也不需要使用缓冲,因为文件自身就有缓冲的行为,而 Logstash 也会记住上次处理的位置。如果服务器性能较差,并不推荐为每个服务器安装 Logstash ,这样就需要一个轻量的日志传输工具,将数据从服务器端经由一个或多个 Logstash 中心服务器传输到 Elasticsearch:随着日志项目的推进,可能会因为性能或代价的问题,需要调整日志传输的方式(log shipper)。当判断 Logstash 的性能是否足够好时,重要的是对吞吐量的需求有着准确的估计,这也决定了需要为 Logstash 投入多少硬件资源。

                                                                 Filebeat

    优势:

           Filebeat 只是一个二进制文件没有任何依赖。它占用资源极少,尽管它还十分年轻,正式因为它简单,所以几乎没有什么可以出错的地方,所以它的可靠性还是很高的。它也为我们提供了很多可以调节的点,例如:它以何种方式搜索新的文件,以及当文件有一段时间没有发生变化时,何时选择关闭文件句柄。

    劣势:

          Filebeat 的应用范围十分有限,所以在某些场景下我们会碰到问题。例如,如果使用 Logstash 作为下游管道,我们同样会遇到性能问题。正因为如此,Filebeat 的范围在扩大。开始时,它只能将日志发送到 Logstash 和 Elasticsearch,而现在它可以将日志发送给 Kafka 和 Redis,在 5.x 版本中,它还具备过滤的能力。

    典型应用场景:

          Filebeat 在解决某些特定的问题时:日志存于文件,我们希望将日志直接传输存储到 Elasticsearch。这仅在我们只是抓去(grep)它们或者日志是存于 JSON 格式(Filebeat 可以解析 JSON)。或者如果打算使用 Elasticsearch 的 Ingest 功能对日志进行解析和丰富。将日志发送到 Kafka/Redis。所以另外一个传输工具(例如,Logstash 或自定义的 Kafka 消费者)可以进一步丰富和转发。这里假设选择的下游传输工具能够满足我们对功能和性能的要求。

                                                                 Logagent

    优势:

           可以获取 /var/log 下的所有信息,解析各种格式(Elasticsearch,Solr,MongoDB,Apache HTTPD等等),它可以掩盖敏感的数据信息,例如,个人验证信息(PII),出生年月日,信用卡号码,等等。它还可以基于 IP 做 GeoIP 丰富地理位置信息(例如,access logs)。同样,它轻量又快速,可以将其置入任何日志块中。在新的 2.0 版本中,它以第三方 node.js 模块化方式增加了支持对输入输出的处理插件。重要的是 Logagent 有本地缓冲,所以不像 Logstash ,在数据传输目的地不可用时会丢失日志。

    劣势:

          尽管 Logagent 有些比较有意思的功能(例如,接收 Heroku 或 CloudFoundry 日志),但是它并没有 Logstash 灵活。

    典型应用场景:

          Logagent 作为一个可以做所有事情的传输工具是值得选择的(提取、解析、缓冲和传输)。

     

                                                            tailf示例:

    package main
    
    import (
    	"fmt"
    	"github.com/hpcloud/tail"
    	"time"
    )
    func main() {
    	filename := "./my.log"
    	tails, err := tail.TailFile(filename, tail.Config{
    		ReOpen:    true,
    		Follow:    true,
    		Location:  &tail.SeekInfo{Offset: 0, Whence: 2},
    		MustExist: false,
    		Poll:      true,
    	})
    	if err != nil {
    		fmt.Println("tail file err:", err)
    		return
    	}
    	var msg *tail.Line
    	var ok bool
    	for true {
    		msg, ok = <-tails.Lines
    		if !ok {
    			fmt.Printf("tail file close reopen, filename:%s\n", tails.Filename)
    			time.Sleep(100 * time.Millisecond)
    			continue
    		}
    		fmt.Println("msg:", msg)
    	}
    }
    

    2.2.2 Kafka介绍

    介绍:

            Kafka是最初由Linkedin公司开发,是一个分布式、支持分区的(partition)、多副本的(replica),基于zookeeper协调的分布式消息系统,它的最大的特性就是可以实时的处理大量数据以满足各种需求场景:比如基于hadoop的批处理系统、低延迟的实时系统、storm/Spark流式处理引擎,web/nginx日志、访问日志,消息服务等等,用scala语言编写,Linkedin于2010年贡献给了Apache基金会并成为顶级开源 项目。

    Kafka的特性:

           高吞吐量、低延迟:kafka每秒可以处理几十万条消息,它的延迟最低只有几毫秒,每个topic可以分多个partition, consumer group 对partition进行consume操作。

    • 可扩展性:kafka集群支持热扩展
    • 持久性、可靠性:消息被持久化到本地磁盘,并且支持数据备份防止数据丢失
    • 容错性:允许集群中节点失败(若副本数量为n,则允许n-1个节点失败)
    • 高并发:支持数千个客户端同时读写

    Kafka的应用场景:

    • 异步处理:把非关键流程异步化,提高系统的响应时间和健壮性

     

    • 应用解耦:通过消息队列

    • 流量削峰:缓存消息

     

    Kafka的原理:

            两个服务器Kafka群集,托管四个分区(P0-P3),包含两个使用者组。消费者组A有两个消费者实例,B组有四个消费者实例。每个实例(server)成为broker。无论是kafka集群,还是producer和consumer都依赖于zookeeper来保证系统可用性集群保存一些meta信息。

     

     

          一个Topic可以认为是一类消息,每个topic将被分成多个partition(区),每个partition在存储层面是append log文件。任何发布到此partition的消息都会被直接追加到log文件的尾部,每条消息在文件中的位置称为offset(偏移量),offset为一个long型数字,它是唯一标记一条消息。它唯一的标记一条消息。kafka并没有提供其他额外的索引机制来存储offset,因为在kafka中几乎不允许对消息进行“随机读写”。

    Kafka使用示例:

    package main
    
    import (
    	"fmt"
    	"github.com/Shopify/sarama"
    )
    
    func main() {
    	config := sarama.NewConfig()
    	config.Producer.RequiredAcks = sarama.WaitForAll
    	config.Producer.Partitioner = sarama.NewRandomPartitioner
    	config.Producer.Return.Successes = true
    
    	msg := &sarama.ProducerMessage{}
    	msg.Topic = "nginx_log"
    	msg.Value = sarama.StringEncoder("this is a good test, my message is good")
    
    	client, err := sarama.NewSyncProducer([]string{"192.168.31.177:9092"}, config)
    	if err != nil {
    		fmt.Println("producer close, err:", err)
    		return
    	}
    
    	defer client.Close()
    
    	pid, offset, err := client.SendMessage(msg)
    	if err != nil {
    		fmt.Println("send message failed,", err)
    		return
    	}
    
    	fmt.Printf("pid:%v offset:%v\n", pid, offset)
    }
    

    2.2.3 Elasticsearch介绍

    介绍:

            Elasticsearch(ES)是一个基于Lucene构建的开源、分布式、RESTful接口的全文搜索引擎。Elasticsearch还是一个分布式文档数据库,其中每个字段均可被索引,而且每个字段的数据均可被搜索,ES能够横向扩展至数以百计的服务器存储以及处理PB级的数据。可以在极短的时间内存储、搜索和分析大量的数据。

    Near Realtime(NRT) 几乎实时

    Elasticsearch是一个几乎实时的搜索平台。意思是,从索引一个文档到这个文档可被搜索只需要一点点的延迟,这个时间一般为毫秒级。

    Cluster 集群

           群集是一个或多个节点(服务器)的集合, 这些节点共同保存整个数据,并在所有节点上提供联合索引和搜索功能。一个集群由一个唯一集群ID确定,并指定一个集群名(默认为“elasticsearch”)。该集群名非常重要,因为节点可以通过这个集群名加入群集,一个节点只能是群集的一部分。

           确保在不同的环境中不要使用相同的群集名称,否则可能会导致连接错误的群集节点。例如,你可以使用logging-dev、logging-stage、logging-prod分别为开发、阶段产品、生产集群做记录。

    Node节点

          节点是单个服务器实例,它是群集的一部分,可以存储数据,并参与群集的索引和搜索功能。就像一个集群,节点的名称默认为一个随机的通用唯一标识符(UUID),确定在启动时分配给该节点。如果不希望默认,可以定义任何节点名。这个名字对管理很重要,目的是要确定你的网络服务器对应于你的ElasticSearch群集节点。

           我们可以通过群集名配置节点以连接特定的群集。默认情况下,每个节点设置加入名为“elasticSearch”的集群。这意味着如果你启动多个节点在网络上,假设他们能发现彼此都会自动形成和加入一个名为“elasticsearch”的集群。

          在单个群集中,您可以拥有尽可能多的节点。此外,如果“elasticsearch”在同一个网络中,没有其他节点正在运行,从单个节点的默认情况下会形成一个新的单节点名为"elasticsearch"的集群。

    Index索引

           索引是具有相似特性的文档集合。例如,可以为客户数据提供索引,为产品目录建立另一个索引,以及为订单数据建立另一个索引。索引由名称(必须全部为小写)标识,该名称用于在对其中的文档执行索引、搜索、更新和删除操作时引用索引。在单个群集中,您可以定义尽可能多的索引。

    Type类型

           在索引中,可以定义一个或多个类型。类型是索引的逻辑类别/分区,其语义完全取决于您。一般来说,类型定义为具有公共字段集的文档。例如,假设你运行一个博客平台,并将所有数据存储在一个索引中。在这个索引中,您可以为用户数据定义一种类型,为博客数据定义另一种类型,以及为注释数据定义另一类型。

     Document文档

          文档是可以被索引的信息的基本单位。例如,您可以为单个客户提供一个文档,单个产品提供另一个文档,以及单个订单提供另一个文档。本文件的表示形式为JSON(JavaScript Object Notation)格式,这是一种非常普遍的互联网数据交换格式。在索引/类型中,您可以存储尽可能多的文档。请注意,尽管文档物理驻留在索引中,文档实际上必须索引或分配到索引中的类型。

    Shards & Replicas分片与副本

           索引可以存储大量的数据,这些数据可能超过单个节点的硬件限制。例如,十亿个文件占用磁盘空间1TB的单指标可能不适合对单个节点的磁盘或可能太慢服务仅从单个节点的搜索请求。为了解决这一问题,Elasticsearch提供细分你的指标分成多个块称为分片的能力。当你创建一个索引,你可以简单地定义你想要的分片数量。每个分片本身是一个全功能的、独立的“指数”,可以托管在集群中的任何节点。

    Shards分片的重要性主要体现在以下两个特征:

    • 分片允许您水平拆分或缩放内容的大小
    • 分片允许你分配和并行操作的碎片(可能在多个节点上)从而提高性能/吞吐量,这个机制中的碎片是分布式的以及其文件汇总到搜索请求是完全由ElasticSearch管理,对用户来说是透明的。

           在同一个集群网络或云环境上,故障是任何时候都会出现的,拥有一个故障转移机制以防分片和结点因为某些原因离线或消失是非常有用的,并且被强烈推荐。为此,Elasticsearch允许你创建一个或多个拷贝,你的索引分片进入所谓的副本或称作复制品的分片,简称Replicas。

    Replicas的重要性主要体现在以下两个特征:

    • 副本为分片或节点失败提供了高可用性。为此,需要注意的是,一个副本的分片不会分配在同一个节点作为原始的或主分片,副本是从主分片那里复制过来的。
    • 副本允许用户扩展你的搜索量或吞吐量,因为搜索可以在所有副本上并行执行。

     Elasticsearch代码示例:

    package main
    
    import (
    	"fmt"
    	elastic "gopkg.in/olivere/elastic.v2"
    )
    
    type Tweet struct {
    	User    string
    	Message string
    }
    
    func main() {
    	client, err := elastic.NewClient(elastic.SetSniff(false), elastic.SetURL("http://192.168.31.177:9200/"))
    	if err != nil {
    		fmt.Println("connect es error", err)
    		return
    	}
    
    	fmt.Println("conn es succ")
    
    	tweet := Tweet{User: "olivere", Message: "Take Five"}
    	_, err = client.Index().
    		Index("twitter").
    		Type("tweet").
    		Id("1").
    		BodyJson(tweet).
    		Do()
    	if err != nil {
    		// Handle error
    		panic(err)
    		return
    	}
    
    	fmt.Println("insert succ")
    }
    

     

    展开全文
  • Eventlog Analyzer日志管理系统、日志分析工具、日志服务器的功能及作用  Eventlog Analyzer是用来分析和审计系统及事件日志的管理软件,能够对全网范围内的主机、服务器、网络设备、数据库以及各种应用服务系统等...

    Eventlog Analyzer日志管理系统、日志分析工具、日志服务器的功能及作用

        Eventlog Analyzer是用来分析和审计系统及事件日志的管理软件,能够对全网范围内的主机、服务器、网络设备、数据库以及各种应用服务系统等产生的日志,进行全面收集和细致分析,通过统一的控制台进行实时可视化的呈现。

        通过定义日志筛选规则和策略,帮助IT管理员从海量日志数据中精确查找关键有用的事件数据,准确定位网络故障并提前识别安全威胁,从而降低系统宕机时间、提升网络性能、保障企业网络安全。

    一、日志管理
    保障网络安全
    Windows系统日志分析
    Syslog日志分析
    应用程序日志分析
    Windows终端服务器日志监控
    Syslog服务器
    通用日志解析 & 索引(ULPI)技术
    事件日志监控
    云设施日志监控
    数据库审计

    应用程序日志分析
    监控和分析应用日志
    IIS Web服务器日志分析
    IIS FTP服务器日志分析
    DHCP Windows应用日志分析
    DHCP Linux应用日志分析
    MS SQL数据库日志分析
    Oracle数据库日志分析
    Apache Web服务器日志分析
    打印机服务器日志分析

    IT合规性审计报表
    满足合规性审计需要
    合规性审计
    PCI合规性报表
    ISO 27001合规性报表
    FISMA合规性报表
    HIPAA合规性报表
    SOX合规性报表
    GLBA合规性报表
    新法规合规性报表
    自定义合规性报表

    系统与用户监控日志报表
    及时了解事件活动
    内建报表
    自定义报表
    微软IIS服务器日志报表
    IBM AS/400日志报表
    VMware服务器日志报表
    活动目录日志报表
    特权用户监控报表
    用户会话监控
    事件日志监控 - 问答报表
    历史事件趋势
    搜索结果报表

    安全信息管理
    管理网络安全信息
    无代理的采集日志方式
    基于代理的采集日志方式
    日志搜索
    日志分析
    日志归档
    日志取证
    日志导入
    用户认证

    安全管理服务提供商(MSSP)
    适用于MSSP的日志管理方案
    操控板与用户视图
    个性化界面

    安全信息和事件管理(SIEM)
    全面保证网络及IT安全
    实时事件关联
    安全日志管理
    服务器日志管理
    日志管理
    文件完整性监控
    安全信息和事件管理(SIEM)

    告警与通知
    及时发现网络故障问题
    实时告警
    邮件、短信通知或运行程序

    集成第三方工具
    扩展管理
    EventLog Analyzer API

    展开全文
  • Java系统日志管理

    万次阅读 2018-07-06 15:24:06
    在一个系统日志管理是一个很重要的部分,因为当系统发布到线网后出了问题只能看系统日志了,这个时候系统日志起到了一个错误排查功能,同时也可以通过系统日志统计用户吞吐量等等,总之系统日志是系统管理一个重点...
    在一个系统中日志管理是一个很重要的部分,因为当系统发布到线网后出了问题只能看系统日志了,这个时候系统日志起到了一个错误排查功能,同时也可以通过系统日志统计用户吞吐量等等,总之系统日志是系统管理一个重点。
    
    本系统架构为SpringMVC,myBatis,Shrio等等。

    1.SpringMVC异常处理
    SpringMVC负责接收用户请求并进行处理然后将结果返回给用户,那么为了不让异常抛给用户,我们一般在Controller类下每个方法都加上一个try{}catch(Exception e){},实例代码如下:
    /**
    	 * pengweikang 20170220 用户登陆
    	 * 
    	 * @param cgbUser
    	 *            用户信息
    	 * @param session
    	 * @return
    	 */
    	@RequestMapping(value = "/login", method = RequestMethod.POST)
    	public @ResponseBody String userLogin(HttpServletRequest request) {
    		try {
    		     .....	 //Service方法调用
    		} catch (Exception e) {
    		     .....      //异常处理
    		} 
    		return null;
    	}

    该方法的缺点是代码冗余,不利于维护,一看就不想是一个专业的软件工程师应该写的,优化办法如下:

    其实SpringMVC给我们提供了一个控制器增强标签,名称为@ControllerAdvice,通过这个标签就可以统一实现异常处理,代码如下:
    创建统一的异常处理类CGBExceptionHandler.java

    import javax.servlet.http.HttpServletRequest;
    import org.apache.commons.lang.exception.ExceptionUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.servlet.config.annotation.EnableWebMvc;
    
    import ch.qos.logback.classic.Level;
    import net.sf.json.JSONObject;
    
    /**
    *@author		create by pengweikang
    *@date		2018年6月27日--下午12:49:23
    *@problem
    *@answer
    *@action
    */
    @ControllerAdvice
    public class CGBExceptionHandler {
    	ch.qos.logback.classic.Logger loggerback = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger("error");
    	{
    		loggerback.setLevel(Level.ERROR);
    	}
        @ExceptionHandler(Exception.class)
        @ResponseBody
        public Object handleException(Exception e,HttpServletRequest rquest) {
        	loggerback.error("错误日志记录");
        	Map dataMap  = rquest.getParameterMap();
            Set<String> keySet = 	dataMap.keySet();
            for(String key : keySet) {
                String [] datas = (String[])dataMap.get(key);
                String value = new String();
                for(String data : datas) {
        	        value +=data+",";
                }
        	    loggerback.error("Param:"+key+" = "+ value.substring(0, value.length() - 1));//将请求参数保存在日志中
            }
        	loggerback.error(ExceptionUtils.getFullStackTrace(e));  // 记录错误信息
            String msg = e.getMessage();
            if (msg == null || msg.equals("")) {
                msg = "服务器出错";
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject.put("message", msg);
            jsonObject.put("state", 0);
            return jsonObject.toString();
        }
    }

    这个时候你的Controller就不用在添加try-catch异常捕获了, 一但方法出了异常就会跳转到CGBExceptionHandler.java这个类的handleException方法。

    2.logback日志管理

    在这个方法中我们将方法调用的的错误消息都记录在日志中,并且将方法调用的参数也报错在错误日志中,logback配置内容如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="http://www.padual.com/java/logback.xsd"
        debug="false" scan="true" scanPeriod="30 second">
    
        <property name="PROJECT" value="recognizeSystem" /> 
        <property name="ROOT" value="/opt/apache-tomcat-7.0.82/logs/${PROJECT}/" />
        <property name="FILESIZE" value="50MB" />
        <property name="MAXHISTORY" value="100" />
        <timestamp key="DATETIME" datePattern="yyyy-MM-dd HH:mm:ss" />
        <!-- 控制台打印 -->
         <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
         	
         	<filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
         
            <encoder charset="utf-8">
                <pattern>[%-5level] %d{${DATETIME}} [%thread] %logger{36} - %m%n
                </pattern>
            </encoder>
        </appender>
        <!-- ERROR 输入到文件,按日期和文件大小 -->
        <appender name="ERROR" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <encoder charset="utf-8">
                <pattern>[%-5level] %d{${DATETIME}} [%thread] %logger{36} - %m%n
                </pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${ROOT}%d/error.%i.log</fileNamePattern>
                <maxHistory>${MAXHISTORY}</maxHistory>
                <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${FILESIZE}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
        
        <!-- WARN 输入到文件,按日期和文件大小 -->
        <appender name="WARN" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <encoder charset="utf-8">
                <pattern>[%-5level] %d{${DATETIME}} [%thread] %logger{36} - %m%n
                </pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>WARN</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${ROOT}%d/warn.%i.log</fileNamePattern>
                <maxHistory>${MAXHISTORY}</maxHistory>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${FILESIZE}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
        
        <!-- INFO 输入到文件,按日期和文件大小 -->
        <appender name="INFO" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <encoder charset="utf-8">
                <pattern>[%-5level] %d{${DATETIME}} [%thread] %logger{36} - %m%n
                </pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>INFO</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${ROOT}%d/info.%i.log</fileNamePattern>
                <maxHistory>${MAXHISTORY}</maxHistory>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${FILESIZE}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
        <!-- DEBUG 输入到文件,按日期和文件大小 -->
        <appender name="DEBUG" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <encoder charset="utf-8">
                <pattern>[%-5level] %d{${DATETIME}} [%thread] %logger{36} - %m%n
                </pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>DEBUG</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${ROOT}%d/debug.%i.log</fileNamePattern>
                <maxHistory>${MAXHISTORY}</maxHistory>
                <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${FILESIZE}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
        <!-- TRACE 输入到文件,按日期和文件大小 -->
        <appender name="TRACE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <encoder charset="utf-8">
                <pattern>[%-5level] %d{${DATETIME}} [%thread] %logger{36} - %m%n
                </pattern>
            </encoder>
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>TRACE</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
            <rollingPolicy
                class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${ROOT}%d/trace.%i.log</fileNamePattern>
                <maxHistory>${MAXHISTORY}</maxHistory>
                <timeBasedFileNamingAndTriggeringPolicy
                    class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>${FILESIZE}</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
            </rollingPolicy>
        </appender>
        
        <!-- SQL相关日志输出-->
        <logger name="org.apache.ibatis" level="INFO" additivity="false" />
        <logger name="org.mybatis.spring" level="INFO" additivity="false" />
        <logger name="com.github.miemiedev.mybatis.paginator" level="INFO" additivity="false" />
        
        <!-- Logger 根目录 -->
        <root level="DEBUG">
             <appender-ref ref="STDOUT" />
             <appender-ref ref="DEBUG" /> 
            <appender-ref ref="ERROR" />
            <appender-ref ref="WARN" />
            <appender-ref ref="INFO" /> 
            <appender-ref ref="TRACE" />
        </root>
    </configuration>

    该配置文件内容为将不同类型的日志按不同文件进行报错,并且每天记录不同的日志,文件夹按日期进行命名,儿控制台只打印错误日志。

    3.测试

    测试代码如下:

    @Controller
    @RequestMapping(value="/test")
    public class TestController {
    @RequestMapping(value="/exception")
    	public @ResponseBody String throwexcep(int data) throws Exception {
    		int a = data/0;// 一定会抛出 java.lang.ArithmeticException: / by zero		
    		return null;
    	}
    }
    请求 http://localhost:8080/logSystem/test/exception?data=100

    首先看tomcat的log文件夹如下图所示:



    error.0.log日志记录如下:

    [ERROR] 2018-07-06 15:05:39 [http-bio-8080-exec-3] error - 错误日志记录
    [ERROR] 2018-07-06 15:09:30 [http-bio-8080-exec-2] error - 错误日志记录
    [ERROR] 2018-07-06 15:09:30 [http-bio-8080-exec-2] error - Param:data = 100
    [ERROR] 2018-07-06 15:09:30 [http-bio-8080-exec-2] error - ParameterMap:org.apache.catalina.util.ParameterMap@c7832d1
    [ERROR] 2018-07-06 15:09:30 [http-bio-8080-exec-2] error - java.lang.ArithmeticException: / by zero
    	at com.goldenbridge.recognizesystem.controller.ActivitiController.throwexcep(ActivitiController.java:137)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:222)
    	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:137)
    	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:110)
    	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:814)
    	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:737)
    	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:85)
    	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:959)
    	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:893)
    	at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:969)
    	at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:860)
    	at javax.servlet.http.HttpServlet.service(HttpServlet.java:624)
    	at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:845)
    	at javax.servlet.http.HttpServlet.service(HttpServlet.java:731)
    	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:303)
    	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)
    	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    	at com.alibaba.druid.support.http.WebStatFilter.doFilter(WebStatFilter.java:123)
    	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    	at org.apache.shiro.web.servlet.ProxiedFilterChain.doFilter(ProxiedFilterChain.java:61)
    	at org.apache.shiro.web.servlet.AdviceFilter.executeChain(AdviceFilter.java:108)
    	at org.apache.shiro.web.servlet.AdviceFilter.doFilterInternal(AdviceFilter.java:137)
    	at org.apache.shiro.web.servlet.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:125)
    	at org.apache.shiro.web.servlet.ProxiedFilterChain.doFilter(ProxiedFilterChain.java:66)
    	at org.apache.shiro.web.servlet.AbstractShiroFilter.executeChain(AbstractShiroFilter.java:449)
    	at org.apache.shiro.web.servlet.AbstractShiroFilter$1.call(AbstractShiroFilter.java:365)
    	at org.apache.shiro.subject.support.SubjectCallable.doCall(SubjectCallable.java:90)
    	at org.apache.shiro.subject.support.SubjectCallable.call(SubjectCallable.java:83)
    	at org.apache.shiro.subject.support.DelegatingSubject.execute(DelegatingSubject.java:383)
    	at org.apache.shiro.web.servlet.AbstractShiroFilter.doFilterInternal(AbstractShiroFilter.java:362)
    	at org.apache.shiro.web.servlet.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:125)
    	at org.springframework.web.filter.DelegatingFilterProxy.invokeDelegate(DelegatingFilterProxy.java:346)
    	at org.springframework.web.filter.DelegatingFilterProxy.doFilter(DelegatingFilterProxy.java:262)
    	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    	at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:121)
    	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:107)
    	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    	at com.goldenbridge.recognizesystem.utils.SimpleCORSFilter.doFilter(SimpleCORSFilter.java:34)
    	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:241)
    	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:208)
    	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:219)
    	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:110)
    	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:506)
    	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:169)
    	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:103)
    	at org.apache.catalina.valves.AccessLogValve.invoke(AccessLogValve.java:962)
    	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:116)
    	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:445)
    	at org.apache.coyote.http11.AbstractHttp11Processor.process(AbstractHttp11Processor.java:1115)
    	at org.apache.coyote.AbstractProtocol$AbstractConnectionHandler.process(AbstractProtocol.java:637)
    	at org.apache.tomcat.util.net.JIoEndpoint$SocketProcessor.run(JIoEndpoint.java:316)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
    	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
    	at java.lang.Thread.run(Thread.java:748)
    
    

    到此系统日志管理配置完成!


    展开全文
  • 统一用户权限管理系统

    千次阅读 2015-01-30 14:53:27
    系统统一的细粒度授权管理和用户统一身份管理及单点认证支撑平台。每个接入的系统都支持自定义权限、配置细粒度用户权限和资源灵活配置。

    统一用户权限管理系统

    演示地址:http://tdog7.oschina.mopaas.com


    简介:本系统为统一的细粒度授权管理和用户统一身份管理及单点认证支撑平台。每个接入的系统都支持自定义权限、配置细粒度用户权限和资源灵活配置。

    系统功能概述:

    1,系统注册:系统注册包括增加、删除、修改、查询和修改密码功能。


    2,用户管理:用户管理包括增加、删除、修改、查询和修改密码功能。


    3,组织机构管理:组织机构管理包括增加、删除、修改和查询功能。


    4,角色管理:角色管理包括增加、删除、修改和查询功能。


    5,资源管理:资源管理包括资源的增加、删除、修改和查询功能。


    6,权限分配管理:资源权限模块根据不同系统对用户、角色和组织分配细粒度权限。
    •  用户资源权限分配
    • 角色资源权限分配
    • 组织资源权限分配

    7,单点登录(SSO):用户单点登录,提供统一用户鉴权功能。


    8,用户会话管理:提供分布式用户会话管理,方式如下
    • Ehcache会话管理
    • Mongodb会话管理

    9,日志管理:提供用户登录日志管理。

    10,对外功能接口概述:
    • 用户鉴权接口
    • 用户数据接口
    • 组织机构数据接口
    • 获取接入系统所有资源接口
    • 获取接入系统所有权限接口
    • 获取用户拥有的权限接口
    • 单点登录(SSO)接口

    平台支持:
    • PC
    • 平板电脑


    展开全文
  • 日志管理方法及系统

    万次阅读 2016-01-16 11:44:06
    本发明涉及应用系统日志管理技术领域,提供了一种日志管理方法和系统,所述方法包括如下步骤:S1:初始化系统业务功能列表和业务功能方法列表;S2:将业务操作中的具体操作信息与系统日志表和历史数据日志表直接相...
  • 背景 ... 在分布式系统当中,我们有各种各样的WebService,这些服务可能分别部署在不同的服务器上,并且有各自的日志...为了方便对这些日志进行统一管理和分析。我们可以将日志统一输出到指定的数据库系统中,而再由日
  • 所以想采用低侵入式的方式来增加日志管理功能。最后决定采用自定义注解加拦截器的方式来完成日志处理。 实现功能类 首先需要一个LogEnum枚举来完成对日志的分类以及在枚举中存储不同的日志处理对象。然后需要一个...
  • 统一权限管理系统 -- UPMS(1)

    千次阅读 2019-10-01 03:53:48
    如果一家公司存在多套系统,那么有一个统一的权限管理系统是尤为重要的。如果没有一个统一的全信管控,那么意味着每个系统都要有自己的权限管控。这对于程序开发来讲是极其浪费成本的,也是灾难性的。 在项目周期...
  • 统一用户权限管理系统(正式版)

    千次阅读 2015-01-08 21:11:56
    系统名称:统一用户权限管理系统  演示地址:http://tdog7.oschina.mopaas.com/    简介:本系统为统一的细粒度授权管理和用户统一身份管理及单点认证支撑平台。每个接入的系统都支持自定义权限、配置细粒度...
  • 基于SSM环境下进行AOP日志的记录,完成存入数据库,取出展示所有数据的需求。
  • Kubernetes-基于EFK进行统一日志管理

    千次阅读 2018-08-23 11:31:02
    通过应用和系统日志可以了解Kubernetes集群内所发生的事情,对于调试问题和监视集群活动来说日志非常有用。对于大部分的应用来说,都会具有某种日志机制。因此,大多数容器引擎同样被设计成支持某种日志机制。对于...
  • linux系统日志管理详解

    千次阅读 2018-02-01 12:13:04
    日志文件记录了时间,地点,人物,事件四大信息,故系统出现故障时,可以查询日志文件。 系统日志文件默认都集中放置到/var/log/目录内,其中又以message记录的信息最多。 日志文件的重要性主要体现在以下三方面...
  • crontab 是 Linux 系统里面最简单易用的定时任务管理工具,相信绝大多数开发和运维都用到过。在咱们公司,很多业务系统的定时任务都是通过 crontab 来定义的,时间长了后会发现存在很多问题: 大量的 crontab 任务...
  • ELK-日志分析系统

    万次阅读 2020-09-23 17:14:47
    需要集中化的日志管理,所有服务器上的日志收集汇总。 解决办法是建立集中式日志收集系统,将所有节点上的日志统一收集,管理,访问。 一般大型系统是一个分布式部署的架构,不同的服务模块部署在不同的服务器上,...
  • 如何在 Rancher 中统一管理容器日志

    千次阅读 2016-12-05 09:35:05
    原文来源:Rancher Labs... 我们在使用 docker 处理日志的时候多数是采用 docker logs 命令,因为 docker 默认采用的 log-driver 是 json-file,所以 docker 会捕捉每一个容器进程 STDOUTS 和 STDERR,保存在磁盘文件
  • MongoDB log4j 日志整合,统一管理

    千次阅读 2015-03-21 20:16:57
    我们可以将日志统一输出到指定的数据库系统中,而再由日志分析系统管理。而这个储存日志的数据库目前最适合的还是mongodb,一是因为它轻便、简单,与log4j整合方便,对系统的侵入性低。二是因为它与大型的关系型...
  • 通过应用和系统日志可以了解Kubernetes集群内所发生的事情,对于调试问题和监视集群活动来说日志非常有用。对于大部分的应用来说,都会具有某种日志机制。因此,大多数容器引擎同样被设计成支持某种日志机制。对于...
  • 接口日志统一处理

    千次阅读 2019-07-27 19:49:47
    重要的接口我们需要记日志以便查找。我们不可能在每个接口中去一一处理,可以借助Spring提供的AOP能力+自定义注解轻松应对。 首先我们定义用于Controller方法的注解,使用了此注解的就记录日志。 /** * 添加了此...
  • 1、内核及系统日志:由系统服务rsyslog统一管理,根据主配文件/etc/rsyslog.conf中的设置决定内核消息及其各种系统消息的记录位置 2、用户日志:记录系统用户登录及其退出系统的相关信息,包括用户名、登录终端、...
  • 用户日志分析系统实战(一)

    千次阅读 2017-11-14 22:21:11
    3. 用户日志分析系统实战(三),资源管理与ETL及其优化 4. 用户日志分析系统实战(四),数据建模、分析与查询 5. 用户日志分析系统实战(五),用户行为分析 6. 用户日志分析系统实战(六),架构思考
  • 用户日志管理

    万次阅读 2018-06-20 15:13:30
    摘要本发明涉及应用系统日志管理技术领域,提供了一种日志管理方法和系统,所述方法包括如下步骤:S1:初始化系统业务功能列表和业务功能方法列表;S2:将业务操作中的具体操作信息与系统日志表和历史数据日志表直接...
  • Linux 日志系统

    千次阅读 2018-09-06 22:08:50
    可以使用日志系统所记录的信息为系统进行排错,优化系统的性能,或者根据这些信息调整系统的行为。收集你想要的数据,分析出有价值的信息,可以提高系统、产品的安全性,还可以帮助开发完善代码,优化产品。日志会...
  • 最佳日志管理工具:51个有用的日志管理、监视、分析等工具 痛苦的纯文本日志管理日子一去不复返了。虽然纯文本数据在某些情况下仍然很有用,但是在进行扩展分析以收集有洞察力的基础设施数据并改进代码质量时,寻找...
  • 在容器化时代,容器应用的日志管理和传统应用存在很大的区别,为了顺应容器化应用,Docker 和 Kubernetes 提供了一套完美的日志解决方案。本文从 Docker 到 Kubernetes 逐步介绍在容器化时代日志的管理机制,以及在 ...
  • Linux日志分析和管理

    千次阅读 2018-09-11 23:08:33
    目录 日志的作用、分类、管理、轮转和级别 rsyslog服务 Journal守护进程 /var/log下相关的日志文件 ...内核及系统日志:由系统服务rsyslog 统一管理日志格式相似 用户日志:记录系统用户登...
  • ELK日志管理平台

    千次阅读 2017-01-12 20:32:24
    日志主要包括系统日志、应用程序日志和安全日志。每条日志都记载着时间戳、主机名、使用者及操作行为等相关的描述,系统运维和开发人员可以通过日志了解服务器软硬件信息、检查配置过程中的错误及错误发生的原因。...
  • Log4j日志集中管理

    千次阅读 2015-01-23 23:20:05
    最近遇到这样一个问题,公司线上有中、日、美三种语言的项目,隶属于不同的三台服务器,且每个项目都通过双节点配置,现想实现日志统一管理,即将所有日志输入到同一台服务器上,然后进行统一记录、管理、分析。...
  • 日志说明以及格式统一规范

    千次阅读 2019-08-07 09:27:50
    日志统一规范 1日志的级别 FATAL、ERROR、WARN、INFO、DEBUG、TRACE,级别越高保存优先级越高,原则上对于ERROR及以上级别的日志永久保留,对于此级别以下的,级别越高保留时间越长。 TRACE 很低的日志级别,一般...
  • 统一身份管理平台系统

    千次阅读 2009-07-16 10:49:00
    应用背景 计算机网络和信息技术的迅速发展使得企业信息化的程度不断提高,在企业信息化过程中,诸如OA、CRM、ERP、OSS等越来越多的业务系统应运而生,提 高了企业的管理水平和运行效率。与此同时,各个应用系统都有...
  • 开源日志系统比较

    千次阅读 2016-03-29 20:14:18
    许多公司的平台每天会产生大量的日志(一般为流式数据,如,搜索引擎的pv,查询等),处理这些日志需要特定的日志系统,一般而言,这些系统需要具有以下特征: (1) 构建应用系统和分析系统的桥梁,并将它们之间...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 157,945
精华内容 63,178
关键字:

统一的日志管理系统