django+tornado实现实时查看远程日志的方法
作者：tuxinhang 发布时间：2021-09-16 07:16:45
标签：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.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
来源：https://blog.csdn.net/tuxinhang/article/details/79132231
0
投稿猜你喜欢
- 以前写JS程序的时候，经常碰到了定位的问题。但每次都看到一半，找到需要的属性就了事了。今天下了狠心，要花点时间，彻底地弄明白他。以下内容看着
1 PHP官网地址：PHP界面：2 下载官网下载地址：Download PHP 或者点击这里下载3 安装① 按照下图下载 php。- 一般常规的我们保存数据为dict类型时，系统会自动帮我们排序；但有时我们想按照输入顺序的key:value保存到dict中，而不想要改变顺序
- 这个类可以用来搜索在给定的文本目录中的文件。 它可以给定目录遍历递归查找某些文件扩展名的文件。 并打开找到的文件，并检查他们是否包含搜索词语
- “用户体验（User Experience，简称UX 或 UE）是一种纯主观的在用户使用一个产品（服务）的过程中建立起来的心理感受。因为它是
- <input name="a" type="checkbox"
- 1 俄罗斯方块游戏《俄罗斯方块》原本是前苏联科学家阿列克谢·帕基特诺夫所开发的教育用软件，之后开始提供授权给各个游戏公
- asp中fso怎样判断一个盘上是否有文件，实例代码，需要的朋友可以试试：<％ dim objfolder dim
- import sysfrom PyQt5 import QtWidgetsfrom PyQt5.QtWidgets import QMain
- MySQL安全性指南(2) 作 者： 晏子2.1.3 数据库和表权限下列权限运用于数据库和表上的操作。ALTER允许你使用ALTER TAB
- 绘制双变量联合分布图有时我们不仅需要查看单个变量的分 布，同时也需要查看变量之间的联系， 往往还需要进行预测等。这时就需要用到双变量联合分布
- 我一般是不看别人写的代码的，为啥？累！而且这位同志给的还是经过压缩的！汗。。。考我是不是？还有，这位同志也不给个示例的代码，只说是代码没有问
- 通过在网络上查找资料和自己的尝试，我认为以下系统参数是比较关键的：(1)、back_log：要求 MySQL 能有的连接数量。当主要MySQ
- 我们的规范到底做到哪一步算是发挥良好的价值？其实一件事物我们理解错根本目的会导致出大不一样的结果，直接反应在设计师到底要体现什么的价值。想想
- 1.锦短情长为什么选择这个标题，借鉴了一封情书里面的情长纸短，还吻你万千。锦短情长都只谓人走茶凉，怎感觉锦短情长？一提起眼泪汪汪，是明月人心
- Python是一种计算机程序设计语言。是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功
- 众所周知，随着数据库体积的日益庞大，其备份文件的大小也水涨船高。虽然说通过差异备份与完全备份配套策略，可以大大的减小SQL Server数据
- 引言本文想要解决的问题是当DataFrame中某一列元素为不定长度的数组时，该如何对它们进行拆分分解为后续元素，从而进行进一步的提取操作，数
- 1、首先模拟python类似shell命令行操作的接口：python安装subprocess（本地）、paramiko（SSH远程）#-*-
- 1:mysql是我们使用最多的数据库，如果在日常中正确的对mysql数据进行备份，下面我们就来做这事，通过脚本来实现############
