django+tornado实现实时查看远程日志的方法

2024-10-20 14:33:04

大致思路：

1.利用tornado提供的websocket功能与浏览器建立长连接，读取实时日志并输出到浏览器

2.写一个实时读取日志的脚本，利用saltstack远程执行，并把实时日志发往redis中。

3.tornado读取redis中的信息，发往浏览器。

此过程用到了redis的发布和订阅功能。

先看一下tornado中是如何处理的：

import os
import sys
import tornado.websocket
import tornado.web
import tornado.ioloop
import redis
import salt.client

from tornado import gen
from tornado.escape import to_unicode

from logs.utility import get_last_lines
from logs import settings

class SubWebSocket(tornado.websocket.WebSocketHandler):
 """
 此handler处理远程日志查看
 """
 def open(self, *args, **kwargs):
  print("opened")

 @gen.coroutine
 def on_message(self, message):
  # 主机名，要查看的日志路径，运行脚本的命令这些信息从浏览器传过来
  hostname, log_path, cmd = message.split("||")
  local = salt.client.LocalClient()
  r = redis.StrictRedis(host=settings.REDIS_HOST, port=settings.REDIS_PORT,
        password=settings.REDIS_PASSWD, db=5)
  # 订阅频道，服务器和日志路径确定一个频道
  key = settings.LOG_KEY.format(server=hostname.strip(), log_path=log_path.strip())
  channel = r.pubsub()
  channel.subscribe(key)
  # 异步方式执行命令，远程运行脚本
  local.cmd_async(hostname, "cmd.run", [cmd])
  try:
   while True:
    data = channel.get_message()
    if not data:
     # 如果读取不到消息，间隔一定时间，避免无谓的CPU消耗
     yield gen.sleep(0.05)
     continue
    if data["type"] == "message":
     line = format_line(data["data"])
     self.write_message(line)
  except tornado.websocket.WebSocketClosedError:
   self.close()

 def on_close(self):
  global FLAG
  FLAG = False
  print("closed")

def format_line(line):
 line = to_unicode(line)
 if "INFO" in line:
  color = "#46A3FF"
 elif "WARN" in line:
  color = "#FFFF37"
 elif "ERROR" in line:
  color = "red"
 elif "CRITICAL" in line:
  color = "red"
 else:
  color = "#FFFFFF"

 return "<span style='color:{}'>{}</span>".format(color, line)

class EchoWebSocket(tornado.websocket.WebSocketHandler):
 def open(self):
  print("WebSocket opened")

 @gen.coroutine
 def on_message(self, message):
  log = message
  print "log file: ", log

  try:
   with open(log, 'r') as f:
    for line in get_last_lines(f):
     line1 = format_line(line)
     self.write_message(line1)
    while True:
     line = f.readline()
     if not line:
      yield gen.sleep(0.05)
      continue
     self.write_message(format_line(line.strip()))
  except tornado.websocket.WebSocketClosedError as e:
   print e
   self.close()

 # def check_origin(self, origin):
 #  print origin, self.request.headers.get("Host")
 #  # super(EchoWebSocket, self).check_origin()
 #  return True

 def on_close(self):
  print("WebSocket closed")

class Application(tornado.web.Application):
 def __init__(self):
  handlers = [
   (r'/log/', MainHandler), # 提供浏览页面，页面中的JS与服务器建立连接
   (r'/log/local', EchoWebSocket), # 处理本地日志实时查看，比较简单
   (r'/log/remote', SubWebSocket), # 处理远程日志实时查看，稍微复杂
  ]
  settings = {
   "debug": True,
   "template_path": os.path.join(os.path.dirname(__file__), "templates"),
   "static_path": os.path.join(os.path.dirname(__file__), "static"),
  }
  super(Application, self).__init__(handlers, **settings)

class MainHandler(tornado.web.RequestHandler):
 def get(self):
  # 要查看的日志路径
  log = self.get_argument("log", None)
  # hostname实际上是saltstack中这台机器对应的minion id
  hostname = self.get_argument("hostname", None)
  # 本地日志还是远程日志
  type = self.get_argument("type", "local")
  # 运行读取实时日志的脚本，参数比较多，后面会有
  cmd = self.get_argument("cmd", "")
  context = {
   "log": log,
   "hostname": hostname,
   "type": type,
   "cmd": cmd,
  }
  self.render("index.html", **context)

配置文件中主要记录了redis服务器的地址等信息

# encoding: utf-8

LOG_KEY = "logs:{server}:{log_path}"

LOG_NAME = "catalina.out"
TAIL_LINE_NUM = 20

REDIS_HOST = "127.0.0.1"
REDIS_PORT = "6379"
REDIS_PASSWD = None
REDIS_EXPIRE = 300

try:
 from local_settings import *
except ImportError:
 pass

index.html的内容如下：

<html>
<head>
<link href="{{ static_url('public/css/public.css') }}" rel="external nofollow" rel="stylesheet" />
<link href="{{ static_url('kylin/css/style.css') }}" rel="external nofollow" rel="stylesheet" />
</head>
<body style="background:#000000">
<div style="margin-left:10px;">
 <pre id="id-content">
 </pre>
 <div id="id-bottom"></div>
 <input type="hidden" id="id-log" value="{{ log }}" />
 <input type="hidden" id="id-type" value="{{ type }}" />
 <input type="hidden" id="id-hostname" value="{{ hostname }}" />
 <input type="hidden" id="id-cmd" value="{{ cmd }}" />
 <div class="btns btns_big">
  <button type="button" class="query_btn cancle" id="id-stop">Stop</button>
  <button type="button" class="query_btn commit" id="id-start">Start</button>
 </div>
</div>
<script type="text/javascript" src="{{ static_url('js/jquery-1.11.3.min.js') }}"></script>
<script type="text/javascript">
 var log_name = $("#id-log").val();
 var type = $("#id-type").val();
 var hostname = $("#id-hostname").val();
 var cmd = $("#id-cmd").val();
 // 初始化websocket对象
 var ws = new WebSocket("ws://{{ request.host }}/log/" + type);
 ws.onopen = function(){
  if (type === "local"){
   ws.send(log_name);
  } else {
   // 建立连接后把相关信息发往服务器，对应上面的SubWebSocket
   ws.send(hostname + "||" + log_name + "||" + cmd);
  }
 };
 var get_message = function(evt){
  $("#id-content").append(evt.data + "\n");
  document.getElementById("id-bottom").scrollIntoView()
 };
 ws.onmessage = get_message;
 // 两个按钮控制日志的输出，如果看到需要的日志信息，可以暂停日志的输出，
 // 之后可以继续启动日志的输出
 $("#id-stop").click(function(){
  ws.onmessage = function(){};
 })
 $("#id-start").click(function(){
  ws.onmessage = get_message;
 })
</script>
</body>
</html>

这个tornado仅仅是提供了实时日志的服务，实际项目使用的是django，django中要做的其实很简单，提供log_name,hostname,type,cmd等四个参数。

下面看一个实例：

class LogView(KylinView):
 # 实时读取日志的脚本，事先使用saltstack批量传到各台服务器上
 client_path = "/tmp/logtail.py"

 def get(self, request):
  minion_id = request.GET.get("minion_id")
  context = {
   "minion_id": minion_id,
   "tail_log_url": settings.TAIL_LOG_URL,
  }
  return render(request, "cmdb/log_view.html", context)

 def post(self, request):
  minion_id = request.POST.get("minion_id")
  log_path = request.POST.get("log_path")
  if not log_path:
   return JsonResponse({"success": False, "message": "请填写日志路径"})
  try:
   # 制定一开始读取的行数
   line_count = request.POST.get("line_count")
  except (TypeError, ValueError):
   return JsonResponse({"success": False, "message": "请输入正确的行数"})
  local = salt.client.LocalClient()
  # 确保saltstack能连通并且日志文件存在
  ret = local.cmd(minion_id, "file.file_exists", [log_path])
  if minion_id not in ret:
   return JsonResponse({"success": False, "message": "服务器无法连通"})
  if not ret[minion_id]:
   return JsonResponse({"success": False, "message": "日志文件不存在"})
  # 组成命令的各个参数，redis信息需要和tornado配置文件中的redis信息一致
  cmd = "{} {} {} {} {} {} {} {}".format(
   settings.PYTHON_BIN, self.client_path, minion_id, log_path, line_count, settings.REDIS_HOST,
   settings.REDIS_PORT, settings.REDIS_PASSWD)
  # settings.TAIL_LOG_URL是tornado中MainHandler对应的url,把其它几个
  # 参数组合成最终的URL，直接访问这个URL就可以在浏览器中实时读取日志了。
  url = "{}?type=remote&log={}&hostname={}&cmd={}".format(
   settings.TAIL_LOG_URL, log_path, minion_id, cmd)
  # 这一步的操作确保同一个日志文件只有一个脚本在读取，避免日志信息重复，这一步
  # 也很重要，必不可少
  local.cmd(minion_id, "cmd.run",
     ["kill `ps aux|grep logtail.py|grep %s|grep -v grep|awk '{print $2}'`" % (log_path,)])
  return JsonResponse({"success": True, "url": url})

下面来看看logtail.py的实现：

# encoding: utf-8
from __future__ import unicode_literals, division

import math
import time
import sys
import socket
import signal
import redis

FLAG = True

def get_last_lines(f, num=10):
 """读取文件的最后几行
 """
 size = 1000
 try:
  f.seek(-size, 2)
 except IOError: # 文件内容不足size
  f.seek(0)
  return f.readlines()[-num:]

 data = f.read()
 lines = data.splitlines()
 n = len(lines)
 while n < num:
  size *= int(math.ceil(num / n))
  try:
   f.seek(-size, 2)
  except IOError:
   f.seek(0)
   return f.readlines()[-num:]
  data = f.read()
  lines = data.splitlines()
  n = len(lines)

 return lines[-num:]

def process_line(r, channel, line):
 r.publish(channel, line.strip())

def sig_handler(signum, frame):
 global FLAG
 FLAG = False

# 收到退出信号后，以比较优雅的方式终止脚本
signal.signal(signal.SIGTERM, sig_handler)
# 为了避免日志输出过多，浏览器承受不住，设置5分钟后脚本自动停止
signal.signal(signal.SIGALRM, sig_handler)
signal.alarm(300)

def get_hostname():
 return socket.gethostname()

def force_str(s):
 if isinstance(s, unicode):
  s = s.encode("utf-8")
 return s

def tail():
 password = sys.argv[6]
 if password == "None":
  password = None
 r = redis.StrictRedis(host=sys.argv[4], port=sys.argv[5], password=password, db=5)
 log_path = sys.argv[2]
 line_count = int(sys.argv[3])
 # 往redis频道发送实时日志
 channel = "logs:{hostname}:{log_path}".format(hostname=sys.argv[1], log_path=log_path)

 with open(log_path, 'r') as f:
  last_lines = get_last_lines(f, line_count)
  for line in last_lines:
   process_line(r, channel, force_str(line))
  try:
   while FLAG: # 通过信号控制这个变量，实现优雅退出循环
    line = f.readline()
    if not line:
     time.sleep(0.05)
     continue
    process_line(r, channel, line)
  except KeyboardInterrupt:
   pass
 print("Exiting...")

if __name__ == "__main__":
 if len(sys.argv) < 6:
  print "Usage: %s minion_id log_path host port redis_pass"
  exit(1)

 tail()

到此为止，整个实时读取远程日志的流程就讲完了。

github: https://github.com/tuxinhang1989/logs

以上这篇django+tornado实现实时查看远程日志的方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持我们。

按日期打印Python的Tornado框架中的日志的方法

网站流量上来后,日志按天甚至小时存储更方便查看和管理,而Python的logging模块也提供了TimedRotatingFileHandler来支持以不同的时间维度归档日志. 然而根据Logging HOWTO的官方指南设置后,却发现新的日志只剩下root的,Tornado内部的logger全部没有生效. 参考stackoverflow上的一个回答,我发现下面的配置能让Tornado内部的logger也用上TimedRotatingFileHandler: # logging.yaml ver
python常用web框架简单性能测试结果分享(包含django、flask、bottle、tornado)

测了一下django.flask.bottle.tornado 框架本身最简单的性能.对django的性能完全无语了. django.flask.bottle 均使用gunicorn+gevent启动,单进程,并且关闭DEBUG,请求均只返回一个字符串ok. tornado直接自己启动,其他内容一致. 测试软件为 siege,测试os为cenos6 64位,测试命令为: 复制代码代码如下: siege -c 100 -r 100 -b http://127.0.0.1:5000/ django
django+tornado实现实时查看远程日志的方法

大致思路: 1.利用tornado提供的websocket功能与浏览器建立长连接,读取实时日志并输出到浏览器 2.写一个实时读取日志的脚本,利用saltstack远程执行,并把实时日志发往redis中. 3.tornado读取redis中的信息,发往浏览器. 此过程用到了redis的发布和订阅功能. 先看一下tornado中是如何处理的: import os import sys import tornado.websocket import tornado.web import tornado
Nginx实现浏览器可实时查看访问日志的步骤详解

一.首先查看nginx版本,我使用的是1.9.7的版本,安装目录在/application/nginx-1.9.7 [root@AnSheng ~]# /application/nginx-1.9.7/sbin/nginx -V nginx version: nginx/1.9.7 built by gcc 4.4.7 20120313 (Red Hat 4.4.7-16) (GCC) configure arguments: --prefix=/application/nginx-1.9.7
python实现tail实时查看服务器日志示例

我就废话不多说了,直接上代码吧! import paramiko from paramiko_expect import SSHClientInteraction host = your host port = your port username = your un # 自行修改输出函数 json_list = [] def output_func(msg): sys.stdout.write(msg) json_list.append(msg) sys.stdout.flush() def
linux下实时查看tomcat运行日志的方法

1.先切换到:cd usr/local/tomcat5/logs 2.tail -f catalina.out 3.这样运行时就可以实时查看运行日志了 Ctrl+c 是退出tail命令. 顺便讲一下Linux中tail命令 tail 命令从指定点开始将文件写到标准输出.使用tail命令的-f选项可以方便的查阅正在改变的日志文件,tail -f filename会把filename里最尾部的内容显示在屏幕上,并且不但刷新,使你看到最新的文件内容. 1．命令格式; tail[必要参数][选择参数][
通过MySQL日志实时查看执行语句以及更新日志的教程

查看MySQL执行的语句想实时查看MySQL所执行的sql语句,类似mssql里的事件探查器.对my.ini文件进行设置,打开文件进行修改: basedir=E:/MySQL 4.0.12 #bind-address=192.168.15.196 datadir=E:/MySQL 4.0.12/data #language=E:/MySQL 4.0.12/share/your language directory #slow query log#=slowqueris.log #tmpdir#
linux tail 查看日志文件方法

tail 命令从指定点开始将文件写到标准输出.使用tail命令的-f选项可以方便的查阅正在改变的日志文件,tail -f filename会把filename里最尾部的内容显示在屏幕上,并且不但刷新,使你看到最新的文件内容. 1．命令格式; tail[必要参数][选择参数][文件] 2．命令功能: 用于显示指定文件末尾内容,不指定文件时,作为输入信息进行处理.常用查看日志文件. -f 循环读取 -q 不显示处理信息 -v 显示详细的处理信息 -c<数目> 显示的字节数 -n<行数>
springboot使用logback文件查看错误日志过程详解

这篇文章主要介绍了springboot使用logback文件查看错误日志过程详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 <?xml version="1.0" encoding="UTF-8"?>  <!-- 日志输出规则根据当前ROOT
docker 查看容器日志命令的实现

为什么要看日志?比如启动容器失败,却不给出任何提示,这时候我们就需要查看下到底是为什么? 查看日志: 命令格式: $ docker logs [OPTIONS] CONTAINER Options: --details 显示更多的信息 -f, --follow 跟踪实时日志 --since string 显示自某个timestamp之后的日志,或相对时间,如42m(即42分钟) --tail string 从日志末尾显示多少行日志, 默认是all -t, --timestamps 显示时间戳 -
教你怎样用Oracle方便地查看报警日志错误

在网上查了几天的资料,尝试综合清除告警日志内容及建外部表的方式来解决这一问题. 一:备份并清除告警日志内容将每天的告警日志备份好,然后进行清除. 1:备份报警日志在$ORACLE_HOME/SID/bdump/ 目录下, 按日期备份alert_ORACLE_你的实例名.LOG这个文件,如:alert_ORACLE_orcl_201408111639_bak.LOG. 2:清除日志内容打开报警日志文件,用true > 文件名可清除掉里面的内容具体示例: 假如,我现在第一次进行该设置,
mysql通过查看跟踪日志跟踪执行的sql语句

在SQL SERVER下跟踪sql采用事件探查器,而在mysql下如何跟踪sql呢? 其实方法很简单,开启mysql的日志log功能,通过查看跟踪日志即可. 开启mysql的日志log方法: windows环境下的配置方法: 我使用的版本:Version: 5.0.37-community-nt-log (MySQL Community Edition (GPL)) 找到my.ini,我的是在"G:\Program Files (x86)\MySQL\MySQL Server 5.0"

django+tornado实现实时查看远程日志的方法

相关推荐

随机推荐