溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章給大家介紹怎么在django中利用tornado查看遠程日志，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。
思路：
1.利用tornado提供的websocket功能與瀏覽器建立長連接，讀取實時日志并輸出到瀏覽器
2.寫一個實時讀取日志的腳本，利用saltstack遠程執行，并把實時日志發往redis中。
3.tornado讀取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:
passindex.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 >
<div >
<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()關于怎么在django中利用tornado查看遠程日志就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
