python监控日志并报警

1. 怎么用python写一个期货突破新高报警的程序

1、首先用python写一个期货突破新高报警的程伏掘序包含两个菜单栏。
2、其次使用Python语言编写缺局核该策略，也非常容易实现。
3、最后加上腊睁回测配置信息，有70行代码，实际可以更加精简。

2. Loguru：Python 日志终极解决方案

日志的作用非常重要，日志可以记录用户的操作、程序的异常，还可以为数据分析提供依据，日志的存在意义就是为了能够在程序在运行过程中记录错误，方便维护和调试，能够快速定位出错的地方，减少维护成本。每个程序员都应该知道，不是为了记录日志而记录日志，日志也不是随意记的。要实现能够只通过日志文件还原整个程序执行的过程，达到能透明地看到程序里执行情况，每个线程、每个过程到底执行到哪的目的。日志就像飞机的黑匣子一样，应当能够复原异常的整个现场乃至细节！

最常见的是把输出函数 print() 当作日志记录的方式，直接打印各种提示信息，常见于个人练习项目里，通常是懒得单独配置日志，而且项目太小不需要日志信息，不需要上线，不需要持续运行，完整的项目不推荐直接打印日志信息，现实中也几乎没有人这么做。

我们可以在不少小项目里面看到作者自己写了一个日志模板，通常利用 print() 或者 sys.stdout 稍微封装一下即可实现简单的日志输出，这里的 sys.stdout 是 Python 中的标准输出流， print() 函数是对 sys.stdout 的高级封装，当我们在 Python 中打印对象调用 print(obj) 时候，事实上是调用了 sys.stdout.write(obj+'\n') ， print() 将内容打印到了控制台，然后追加了一个换行符 \n 。

自写日志模板适合比较小的项目，可以按照自己的喜好编写模板，不需要太多复杂配置，方便快捷，但是这种记录日志的方式并不是很规范，有可能你自己觉得阅读体验不错，但是别人在接触你的项目的时候往往需要花费一定的时间去学习日志的逻辑、格式、输出方式等，比较大的项目同样不推荐这种方法。

一个简单的自写日志模板举例：

日志模板 log.py：

调用日志模块：

日志输出：

在一个完整的项目中，大多数人都会引入专门的日志记录库，而 Python 自带的标准库 logging 就是专门为日志记录而生的，logging 模块定义的函数和类为应用程序和库的开发实现了一个灵活的事件日志系统。由标准库模块提供日志记录 API 的关键好处是所有 Python 模块都可以使用这个日志记录功能。所以，你的应用日志可以将你自己的日志信息与来自第三方模块的信息整合起来。

logging 模块虽然强大，但是其配置也是比较繁琐的，在大型项目中通常需要单独初始化日志、配置日志格式等等，K哥在日常使用中通常都会对 logging 做如下的封装写法，使日志可以按天保存，保留15天的日志，可以配置是否输出到控制台和文件，如下所示：

输出日志：

它在控制台中是这样的：

当然，如果你不需要很复杂的功能，希望简洁一点，仅仅需要在控制台输出一下日志的话，也可以只进行简单的配置：

对于 logging 模块，即便是简单的使用，也需要自己定义格式，这里介绍一个更加优雅、高效、简洁的第三方模块：loguru，官方的介绍是：Loguru is a library which aims to bring enjoyable logging in Python. Loguru 旨在为 Python 带来愉快的日志记录。这里引用官方的一个 GIF 来快速演示其功能：

Loguru 仅支持 Python 3.5 及以上的版本，使用 pip 安装即可：

Loguru 的主要概念是只有一个：logger

控制台输出：

可以看到不需要手动设置，Loguru 会提前配置一些基础信息，自动输出时间、日志级别、模块名、行号等信息，而且根据等级的不同，还自动设置了不同的颜色，方便观察，真正做到了开箱即用！

如果想自定义日志级别，自定义日志格式，保存日志到文件该怎么办？与 logging 模块不同，不需要 Handler，不需要 Formatter，只需要一个 add() 函数就可以了，例如我们想把日志储存到文件：

我们不需要像 logging 模块一样再声明一个 FileHandler 了，就一行 add() 语句搞定，运行之后会发现目录下 test.log 里面同样出现了刚刚控制台输出的 debug 信息。

与 add() 语句相反， remove() 语句可以删除我们添加的配置：

此时控制台会输出两条 debug 信息：

而 test.log 日志文件里面只有一条 debug 信息，原因就在于我们在第二条 debug 语句之前使用了 remove() 语句。

Loguru 对输出到文件的配置有非常强大的支持，比如支持输出到多个文件，分级别分别输出，过大创建新文件，过久自动删除等等。 下面我们来详细看一下 add() 语句的详细参数：

基本语法：

基本参数释义：

当且仅当 sink 是协程函数时，以下参数适用：

当且仅当 sink 是文件路径时，以下参数适用：

这么多参数可以见识到 add() 函数的强大之处，仅仅一个函数就能实现 logging 模块的诸多功能，接下来介绍几个比较常用的方法。

add() 函数的 rotation 参数，可以实现按照固定时间创建新的日志文件，比如设置每天 0 点新创建一个 log 文件：

设置超过 500 MB 新创建一个 log 文件：

设置每隔一个周新创建一个 log 文件：

add() 函数的 retention 参数，可以设置日志的最长保留时间，比如设置日志文件最长保留 15 天：

设置日志文件最多保留 10 个：

也可以是一个 datetime.timedelta 对象，比如设置日志文件最多保留 5 个小时：

add() 函数的 compression 参数，可以配置日志文件的压缩格式，这样可以更加节省存储空间，比如设置使用 zip 文件格式保存：

其格式支持： gz 、 bz2 、 xz 、 lzma 、 tar 、 tar.gz 、 tar.bz2 、 tar.xz

Loguru 在输出 log 的时候还提供了非常友好的字符串格式化功能，相当于 str.format() ：

输出：

在 Loguru 里可以直接使用它提供的装饰器就可以直接进行异常捕获，而且得到的日志是无比详细的：

日志输出：

在控制台的输出是这样的：

相比 Logging，Loguru 无论是在配置方面、日志输出样式还是异常追踪，都远优于 Logging，使用 Loguru 无疑能提升开发人员效率。本文仅介绍了一些常用的方法，想要详细了解可参考 Loguru 官方文档 或关注 Loguru GitHub 。

3. 监控一个持续刷新的日志文件/var/log/messages,命令是什么/var/log/messages

Zabbix Advance - linux log monitor 日志监控（/var/log/messages,/var/log/secure,其它程序日志皆可） 原创
2020-09-11 10:43:40
2点赞

Fei-Huang

码龄12年

关注
文章目录
日志监控原理
本文档示例版本与官方使用文档
配置过程
一，被监控的主机上配置zabbix_agentd.conf
二，修改日志文件的权限
修改前日志文件的权限：
修改日志文件的权限
查看修改后的文件权限
三，配置zabbix web item页面(监控root用户登陆)
root用户登陆测试庆凳皮
配置告警（trigger）
最终配置
再次测试root登陆
日志监控原理
zabbix 监控日志，主要是用于监控日志中的关键字，遇到关键字后，zabbix agent 将日志发送给server。日志监控必需是agent active的监控项目

本文档示例版本与官方使用文档
官方文档链接

配置过程
一，被监控的主机上配置zabbix_agentd.conf
[root@GuangGu_Zabbix_proxy ~]# egrep -v "#|^$" /etc/zabbix/zabbix_agent2.conf
PidFile=/var/run/zabbix/zabbix_agent2.pid
LogFile=/var/log/zabbix/zabbix_agent2.log
LogFileSize=0
Server=X.X.X.X
ServerActive=X.X.X.X
Hostname=Zabbix_lOG
Include=/etc/zabbix/zabbix_agent2.d/*.conf
ControlSocket=/tmp/agent.sock
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
ServerActive=X.X.X.X
Hostname=Zabbix_lOG
以上两个参数配置对日志很重要，agent active 在发送数据给server端时，会将配置文件中的hostname的值做为一个值携带给服务端，zabbix_server收到发送过来的数据后会主动匹配这个值，是否与自己配置的主机的粗贺hostname一致，一致即接收数据，放置在数据库中。

二，修改日志文件的权限
通常情况下，/var/log/目录下的系统日志文件只有root用户有相应的读写权限，而zabbix对这些文件需要有读取的誉差权限，否则无法监控，所以在不更改属主属组的情况下，使用==“facl”== 添加文件权限比较合适，以下为示例：

修改前日志文件的权限：
[hostname]# ls -l /var/log/messages
-rw------- 1 root root 138063 Sep 11 08:10 /var/log/messages
1
2
1
2
只有root用户有读写权限，其它的用户均没有权限

修改日志文件的权限
setfacl -m u:zabbix:r-- /var/log/messages
1
1
查看修改后的文件权限
[root@GuangGu_Zabbix_proxy ~]# ls -l /var/log/messages
-rw-r-----+ 1 root root 193670 Sep 11 09:10 /var/log/messages
1
2
1
2
[root@GuangGu_Zabbix_proxy ~]# getfacl /var/log/messages
getfacl: Removing leading '/' from absolute path names
# file: var/log/messages
# owner: root
# group: root
user::rw-
user:zabbix:r--
group::---
mask::r--
other::---

1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11
user:zabbix:r-- 可以看到zabbix用户有r的权限了
但是这条命令只设置了当前的/var/log/messages的文件的权限，这个日志文件是会随日期滚动的所以还需要设置一下日志滚动后的zabbix用户的权限，此时还需要修改另外一个文件的内容：

[root@hostname~]# vim /etc/logrotate.d/syslog
/var/log/cron
/var/log/maillog
/var/log/messages
/var/log/secure
/var/log/spooler
{
missingok
sharedscripts
postrotate
/bin/kill -HUP `cat /var/run/syslogd.pid 2> /dev/null` 2> /dev/null || true
/usr/bin/setfacl -m u:zabbix:r-- /var/log/messages
endscript
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14
logrotate 不是守护进程的服务，所以不需要重启

三，配置zabbix web item页面(监控root用户登陆)
key : log[file,<regexp>,<encoding>,<maxlines>,<mode>,<output>,<maxdelay>,<options>]
/var/log/messages 中 root 用户登陆的日志记录如下：

Sep 11 09:30:01 LOGMONITOR systemd: Started Session 6787 of user root.
1
1

几个注意点：

类型必需是“zabbix agent active”的
信息类型必需是“日志”型的
log[/var/log/messages, Started Session .* of user root.$,skip,]

root用户登陆测试
Sep 11 09:44:47 LOGMONITOR systemd-logind: New session 6789 of user root.
Sep 11 09:44:47 LOGMONITOR systemd: Started Session 6789 of user root.
Sep 11 09:44:47 LOGMONITOR systemd: Starting Session 6789 of user root.
1
2
3
1
2
3
以上三条是登陆产生的日志
查看zabbix监控的消息记录

点击“历史记录查看”

zabbix已经收到相关日志

配置告警（trigger）
配置告警思路：

只要zabbix收到相应条目的日志一次，就触发一次告警
收到告警后，如果60s内没有再次触发告警就消失
最终配置

再次测试root登陆

此告警60S后消失

文章知识点与官方知识档案匹配
CS入门技能树Linux入门初识Linux
24650 人正在系统学习中
打开CSDN APP，看更多技术内容

zabbix监控Linux进程方法_lihuaichen的博客
利用zabbixproc.num方法监控Linux服务进程 proc.num[<name>,<user>,<state>,<cmdline>] 监控用户某些状态的进程的数量 name- 进程名称 (默认“all processes”)user- 用户名 (默认 “all users”)state- 可用值:all(默认),run,sl...
继续访问
zabbix监控远程linux服务器基础操作_今天摘太阳的博客_linu...
查看添加的监控主机的最新数据是否监控到数据。4. 通过web页面配置linux监控,添加监控主机及套用模板设置。 zabbix监控Linux流程 m0_52091913的博客 312 zabbix监控Linux流程,邮件警告 远程监控 linux服务器软件,如何从Web浏览器远程监控...
继续访问
log_monitor日志监控
对qps以及接口的平均耗时进行统计 特点 (1)轻量: 共219KB(代码量约300行), 无需安装,解压即可使用 (2)低侵入: 基于日志文件进行统计,无需修改原程序 使用说明 (1) 二进制包:下载工具包 log_monitor.tar.gz,并解压 (2) 源码编译:make 之后进行参数配置,可以拷贝现有的,各个参数说明如下: log_file=/data/nginx_logs/access.log log_reg=
(.∗)\+0800
(.∗)\+0800
time_format=%d/%b/%Y:%H:%M:%S retain_seconds=3600 http_port=3344 log_level=INFO log_file: 需要监控的日志的路径 log_reg: 需要匹配的日期以及耗时信息的正则表达式(需要加括号) time_format: 日志中日期的格式 retain_seconds: 统计数据保留时间 http_port: 用来通过页面展示统计数据的端口 log_level: log monitor的日志级别 启动 ./bin/log_monitor [conf_file_path] 查看 (1) 在控制台就可以看到系统实时的qps以及每一秒中接口的平均耗时情况 (2) 通过浏览器访问 http://${ip}:{http_port}/show.html
Zabbix监控之Linux命令行/Shell脚本解析json
本文主要写了在Linux下如何用Shell脚本解析json数据，以便于在Zabbix中添加适合于业务应用的监控项。为什么要使用json？json作为一种文本化的数据格式（文本化协议），符合UNIX编程的哲学，既符合透明性（透明性：设计可见，便于审查和调试）又符合文本性（文本性：数据应该保存为文本文件）。关键在于json对Web程序或者java程序非常友好，对于开发人员来说，他们也喜欢使用json数...
继续访问
linux启动zabbix服务,zabbix监控Linux系统服务_邓琨腾的博客
Zabbix自动发现规则监控Linux系统的service units 项目要求:通过systemctl命令查看Linux系统的service units; 监控前提:zabbix环境已搭建好; 监控原理:通过shell脚本把systemctl命令返回的结果以json格式发送到zabbix; ...
继续访问
zabbix自动监控linux进程,zabbix远程命令-监控进程停掉后自动重启应用...
6.在验证远程命令的可用性之后,在zabbix前端页面添加监控项,设置触发器,并添加执行远程命令的动作。 7.添加监控项: 自定义名称,类型为zabbix客户端,键值为proc.num[,,,httpd],其他自定义,点击添加。
继续访问
zabbix监控日志
zabbix监控日志
继续访问

linux的数据清洗视频,Zabbix监控历史数据清理
Zabbix监控运行一段时间以后，会留下大量的历史监控数据，Zabbix数据库一直在增大；可能会造成系统性能下降，查看历史数据室查询速度缓慢。Zabbix里面最大的表就是history和history_uint两个表，而且zabbix里面的时间是使用的时间戳方式记录，所以可以根据时间戳来删除历史数据一、关闭zabbix、http服务pkill -9 zabbixservice httpd stop...
继续访问
zabbix3.4监控linux磁盘使用率_一文看懂Linux全能型监控命令--dstat...
在linux上有top、free、iostat、vmstat、netstat等诸多监控系统各项性能的工具,如top,可以实时监控到系统负载、内存等使用情况,iostat能监控系统I/O情况,而vmstat可以得到关于进程、内存、内存分页、堵塞IO、traps及CPU活动的信息。不过今天主...
继续访问
Zabbix监控Linux进程方法
利用zabbix proc.num方法监控Linux服务进程 proc.num[<name>,<user>,<state>,<cmdline>] 监控用户某些状态的进程的数量 name - 进程名称 (默认“all processes”) user - 用户名 (默认 “all users”) state - 可用值: all (默认), run,sleep, zomb cmdline - 命令行过滤(正则表达时) 一、首先新建一个模板，在监控项条目中新
继续访问

关于/var/log/messages文件
/var 包括系统运行时要改变的数据。其中包括每个系统是特定的，即不能够与其他计算机共享的目录，如/var/log，/var/lock，/var/run。有些目录还是可以与其他系统共享，如/var/mail, /var/cache/man, /var/cache/fonts,/var/spool/news。var目录存在的目的是把usr目录在运行过程中需要更改的文件或者临时生成的文件及目录提取出来
继续访问
@Zabbix常用的监控命令及监控分析
文章目录一、面试技巧1.面试常问二、单机监控命令1.CPU 监控命令2.内存监控命令3.磁盘监控命令4.网络监控命令5.TCP11种状态监控命令6.生产场景需求7.系统的oom(out of memory)8.使用脚本监控nginx三、zabbix数据库拆分1.环境准备2.导出原MySQL中的zabbix数据3.准备新的数据库环境4.关闭原来的数据库测试5.修改连接数据库代码 一、面试技巧 1.面试常问 #1.面试官：你们公司监控是如何做的？ 你：用zabbix 面试官：.... #2.面试技
继续访问
最新发布 zabbix日志监控：操作系统、业务系统、文件大小、多行日志
(一)监控操作系统日志 (二)监控业务系统日志 (三)监控日志文件大小 (四)多行日志监控- Python脚本优化
继续访问

zabbix 时间错误_使用Zabbix来监控系统日志
在Linux系统上，日志文件通常可以分为四类：System Logs(系统日志)Event Logs(事件日志)Application Logs(应用程序日志)Service Logs(服务日志)一、为什么要监控日志？Linux为了跟踪和监视系统(内核)各个组件及应用程序运行状态而将产生的相关事件存储到日志文件中，当系统或者应用程序出现问题时，系统管理员能根据日志定位到问题。而通过监控Linux的...
继续访问
【Docker学习】13、使用 Docker/Docker-Compose 部署 Prometheus 监控组件
文章目录1、Prometheus 监控组件（1）Prometheus 监控 Linux（2）Prometheus 监控 Docker（3）Prometheus 监控 MySQL 1、Prometheus 监控组件 从上面的构建可以发现，现在已经可以监控当前Linux主机了，实际上能监控的内容很多，可以在官网查看，监控内容或社区查找 搭建各种组件的监控，首先需要找到提供数据的数据源，当然，Prometheus已经给我们写好了配置，我们只需要在找到对应的配置进行安装即可，Prometheus GitHub，例如
继续访问

Linux从入门到放弃 zabbix常见的linux监控命令
cpu top htop uptime vmstat 内存 free 磁盘 df iotop 网卡 iftop nethogs 系统进程 ps pstree
继续访问
zabix监控linux进程名称,zabbix监控Linux进程方法
利用zabbixproc.num方法监控Linux服务进程proc.num[,,,]监控用户某些状态的进程的数量name- 进程名称 (默认“all processes”)user- 用户名 (默认 “all users”)state- 可用值:all(默认),run,sleep,zombcmdline-命令行过滤(正则表达时)具体监控某一服务进程的方法一、首先新建一个模板，在监控项条目中新建一...
继续访问

zabbix监控Linux流程
zabbix监控Linux流程，邮件警告
继续访问

zabbix监控linux文件目录,zabbix之日志文件监控
一、日志item介绍下面介绍zabbix另一个“重量级”的功能——日志文件监控，它最主要的是监控日志文件中有没有某个字符串的表达式，对应日志轮转与否，zabbix都支持。在配置Item的时候，Type选择Zabbix agent (active)，这里主要需要配置的是Key。下面是监控日志的两种key——log和logtr。log[/path/to/some/file,,,,,]logtr[/pa...
继续访问

监控linux日志,Zabbix日志监控：Linux异常登录告警
本文利用zabbix的日志监控功能监控Linux的secure日志，当有用户登录失败或者用户在非常规时间登录成功时发出告警。这里我们使用zabbix提供的'log[file,,,,,]'来监控Linux的/var/log/secure文件。先介绍下这个log监控项：1)监控项类型是Zabbix agent (active)，返回数据类型是Log。2)Zabbix agent要对监控的日志文件有可读...
继续访问

Zabbix监控日志
创建监控项 创建触发器 验证 问题定位 创建监控项 注意要选择客户端主动式，使用主动式的时候无法使用zabbix-get工具调试 键值示例：log[/home/moa/log/smapd/smapd.log,”info”,,,skip,,] 说明：1、/home/moa/log/smapd/smapd.log表示日志路径 2、”info”表示匹配的关键字...
继续访问
zabbix监控日志关键字（ERROR）
前言：对我我这种刚入职场不久的小运维来说其实这个对我来说真的挺难得，研究了好久也在朋友的帮助下终于成功了，在此多谢我的朋友（倪伟）。 公司没有zabbix监控，领导让搭建一套zabbix然后让监控错误日志（关键字error），其实据说牛掰的大神可以监控到具体报错信息是什么，如有大神能编写出来欢迎指教。 因为就是想让他提醒一次就不在提醒了，所以脚本我写了半天(不擅长啊） 我zabbix搭建的过...
继续访问
热门推荐 Linux实时查看文件/var/log/messages以及这个文件的问题
耐心看完说不定有你遇到的问题 1./var/log/messages 首先说一下这个文件的存在,在Ubuntu系统中,这个文件你访问可能提示找不到这个文件 //使用tail命令访问 name@name:~$ sudo tail /var/log/messages tail:无法打开'/var/log/messages' 读取数据: 没有那个文件或目录 tail:没有剩余文件 可能会出现...
继续访问
Zabbix使用总结
1. CentOS 7上启动zabbix-server失败，/var/log/messages中的报错信息如下： Feb 22 12:56:43 mysql-server1 systemd: Starting Zabbix Server with MySQL DB... Feb 22 12:56:43 mysql-server1 kernel: zabbix_server[1599]: s
继续访问
zabbix监控linux历史命令
zabbix
写评论

评论

3

4. 如何用python写监控日志函数

defwrite_log(username,operation):
'''
写日志函数
:paramusername:用户名
:paramoperation:用户的操作信息
:return:
'''
w_time=time.strftime('%Y-%m-%d%H%M%S')
withopen('log.txt','a+')asfw:
log_content='%s%s%s
'%(w_time,username,operation)
fw.write(log_content)

希望对你有帮助！

5. 在 python 项目中如何记录日志

写本文的目的是我在写 python 项目的时候需要记录日志，我忘记怎么处理了，每次码逗竖都需要去网上查一遍， 好记性不如烂笔头 ， 这里把查阅的内容记录下来，方便以后查找。

python 项目中记录日志，可以使用 logging 模块，logging 模块定义的函数和类为应用程序和指岁库的开发实现了一个灵活的事件日志系统。logging 模块是Python的一个标准库模块，由标准库模块提供日志记录API的关键好处是所有Python模块都可以使用这个日志记录功能。所以，你的应用日志可以将你自己的日志信息与来自第三方模块迟大的信息整合起来。

在 __init__.py 文件中做如下配置：

控制台输出日志如下：

参考文档
https://www.cnblogs.com/yyds/p/6901864.html

6. zabbix日志监控告警怎么消失

使用shell或者python脚本对系统日志进行过滤出错误日志，重定盯键向到指定文件。然后在zabbix定义模板对该脚本进行监控。并指定触发橘则高事件，当系统出现错误日志时，圆尺触发警告。

7. Python日志—Python日志模块logging介绍

从事与软件相关工作的人，应该都听过“日志”一词。

日志就是跟踪软件运行时事件的方法，为了能够在程序运行过程中记录错误。

通过日志记录程序的运行，方便我们查询信息，以便追踪问题、进行维护和调试、还是数据分析。

并且各编程语言都形成了各自的日志体系和相应的框架。

日志的作用总结：

首先我们要树立一个观点，那就是“不是为了记录日志而记录日志，日志也不是随意记的”。要实现能够只通过日志文件还原整个程序执行的过程，达到能透明地看到程序里执行情况，每个线程每个过程到底执行结果的目的。日志就像飞机的黑匣子一样，应当能够复原异常的整个现场乃至细节。

在项目中，日志这个功能非常重要，我们要重视起来。

在Python中，使用logging模块来进行日志的处理。

logging是Python的内置模块，主要用于将日志信息进行格式化内容输出，可将格式化内容输出到文件，也可输出到屏幕。

我们在开发过程中，常用print()函数来进行调试，但是在实际应用的部署时，我们要将日志信息输出到文件中，方便后续查找以及备份。

在我们使用日志管理时，我们也可以将日志格式化成Json对象转存到ELK中方便图形化查看及管理。

logging模块将日志系统从高向低依次定义了四个类，分别是logger（日志器）、handler（处理器）、filter(过滤器)和formatter(格式器)。其中由日志器生成的实例将接管原本日志记录函数logging.log的功能。

说明：

我们先来思考下下面的两个问题：

在软件开发阶段或部署开发环境时，为了尽可能详细的查看应用程序的运行状态来保证上线后的稳定性，我们可能需要把该应用程序所有的运行日志全部记录下来进行分析，这是非常耗费机器性能的。

当应用程序正式发布或在生产环境部署应用程序时，我们通常只需要记录应用程序的异常信息、错误信息等，这样既可以减小服务器的I/O压力，也可以避免我们在排查故障时被淹没在日志的海洋里。

那么怎样才能在不改动应用程序代码的情况下，根据事件的重要性或者称之为等级，实现在不同的环境中，记录不同详细程度的日志呢？

这就是日志等级的作用了，我们通过配置文件指定我们需要的日志等级就可以了。

说明：

总结：

开发应用程序时或部署开发环境时，可以使用DEBUG或INFO级别的日志获取尽可能详细的日志信息，可以方便进行开发或部署调试。 应用上线或部署生产环境时，应用使用WARNING或ERROR或CRITICAL级别的日志，来降低机器的I/O压力和提高获取错误日志信息的效率。 日志级别的指定通常都是在应用程序的配置文件中进行指定的。 不同的应用程序所定义的日志等级会有所差别，根据实际需求来决定。

8. python 运维常用脚本

Python 批量遍历目录文件,并修改访问时间

import os

path = "D:/UASM64/include/"
dirs = os.listdir(path)
temp=[];

for file in dirs:
temp.append(os.path.join(path, file))
for x in temp:
os.utime(x, (1577808000, 1577808000))
Python 实现的自动化服务器管理

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):

def ssh_put(user,passwd,source,target):

while True:
try:
shell=str(input("[Shell] # "))
if (shell == ""):
continue
elif (shell == "exit"):
exit()
elif (shell == "put"):
ssh_put("root","123123","./a.py","/root/a.py")
elif (shell =="cron"):
temp=input("输入一个计划任务: ")
temp1="(crontab -l; echo "+ temp + ") |crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
elif (shell == "uncron"):
temp=input("输入要删除的计划任务: ")
temp1="crontab -l | grep -v " "+ temp + "|crontab"
ssh_cmd("root","123123","22","./user_ip.conf",temp1)
else:
ssh_cmd("lyshark","123123","22","./user_ip.conf",shell)

遍历目录和文件

import os

def list_all_files(rootdir):
import os
_files = []
list = os.listdir(rootdir) #列出文件夹下所有的目录与文件
for i in range(0,len(list)):
path = os.path.join(rootdir,list[i])
if os.path.isdir(path):
_files.extend(list_all_files(path))
if os.path.isfile(path):
_files.append(path)
return _files

a=list_all_files("C:/Users/LyShark/Desktop/a")
print(a)
python检测指定端口状态

import socket

sk = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sk.settimeout(1)

for ip in range(0,254):
try:
sk.connect(("192.168.1."+str(ip),443))
print("192.168.1.%d server open "%ip)
except Exception:
print("192.168.1.%d server not open"%ip)

sk.close()

python实现批量执行CMD命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

print("------------------------------> ")
print("使用说明,在当前目录创建ip.txt写入ip地址")
print("------------------------------> ")

user=input("输入用户名:")
passwd=input("输入密码:")
port=input("输入端口:")
cmd=input("输入执行的命令:")

file = open("./ip.txt", "r")
line = file.readlines()

for i in range(len(line)):
print("对IP: %s 执行"%line[i].strip(' '))

python3-实现钉钉报警

import requests
import sys
import json

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

data = {"msgtype": "markdown","markdown": {"title": "监控","text": "apche异常"}}

headers = {'Content-Type':'application/json;charset=UTF-8'}

send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

import psutil
import requests
import time
import os
import json

monitor_name = set(['httpd','cobblerd']) # 用户指定监控的服务进程名称

proc_dict = {}
proc_name = set() # 系统检测的进程名称
monitor_map = {
'httpd': 'systemctl restart httpd',
'cobblerd': 'systemctl restart cobblerd' # 系统在进程down掉后，自动重启
}

dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='

while True:
for proc in psutil.process_iter(attrs=['pid','name']):
proc_dict[proc.info['pid']] = proc.info['name']
proc_name.add(proc.info['name'])

判断指定端口是否开放

import socket

port_number = [135,443,80]

for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
print("Port %d is not open" % index)
sock.close()

判断指定端口并且实现钉钉轮询报警

import requests
import sys
import json
import socket
import time

def dingding(title,text):
dingding_url = ' https://oapi.dingtalk.com/robot/send?access_token='
data = {"msgtype": "markdown","markdown": {"title": title,"text": text}}
headers = {'Content-Type':'application/json;charset=UTF-8'}
send_data = json.mps(data).encode('utf-8')
requests.post(url=dingding_url,data=send_data,headers=headers)

def net_scan():
port_number = [80,135,443]
for index in port_number:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
result = sock.connect_ex((飗.0.0.1', index))
if result == 0:
print("Port %d is open" % index)
else:
return index
sock.close()

while True:
dingding("Warning",net_scan())
time.sleep(60)

python-实现SSH批量CMD执行命令

import sys
import os
import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())

def ssh_cmd(user,passwd,port,userfile,cmd):
file = open(userfile, "r")
line = file.readlines()
for i in range(len(line)):
print("对IP: %s 执行"%line[i].strip(' '))
ssh.connect(hostname=line[i].strip(' '),port=port,username=user,password=passwd)
cmd=cmd
stdin, stdout, stderr = ssh.exec_command(cmd)
result = stdout.read()

ssh_cmd("lyshark","123","22","./ip.txt","free -h |grep 'Mem:' |awk '{print $3}'")

用python写一个列举当前目录以及所有子目录下的文件，并打印出绝对路径

import sys
import os

for root,dirs,files in os.walk("C://"):
for name in files:
print(os.path.join(root,name))
os.walk()

按照这样的日期格式（xxxx-xx-xx）每日生成一个文件，例如今天生成的文件为2013-09-23.log， 并且把磁盘的使用情况写到到这个文件中。

import os
import sys
import time

new_time = time.strftime("%Y-%m-%d")
disk_status = os.popen("df -h").readlines()

str1 = ''.join(disk_status)
f = open(new_time+'.log','w')
f.write("%s"%str1)

f.flush()
f.close()

统计出每个IP的访问量有多少？（从日志文件中查找）

import sys

list = []

f = open("/var/log/httpd/access_log","r")
str1 = f.readlines()
f.close()

for i in str1:
ip=i.split()[0]
list.append(ip)

list_num=set(list)

for j in list_num:
num=list.count(j)
print("%s -----> %s" %(num,j))

写个程序，接受用户输入数字，并进行校验，非数字给出错误提示，然后重新等待用户输入。

import tab
import sys

while True:
try:
num=int(input("输入数字：").strip())
for x in range(2,num+1):
for y in range(2,x):
if x % y == 0:
break
else:
print(x)
except ValueError:
print("您输入的不是数字")
except KeyboardInterrupt:
sys.exit(" ")

ps 可以查看进程的内存占用大小，写一个脚本计算一下所有进程所占用内存大小的和。

import sys
import os

list=[]
sum=0

str1=os.popen("ps aux","r").readlines()

for i in str1:
str2=i.split()
new_rss=str2[5]
list.append(new_rss)
for i in list[1:-1]:
num=int(i)
sum=sum+num

print("%s ---> %s"%(list[0],sum))

关于Python 命令行参数argv

import sys

if len(sys.argv) < 2:
print ("没有输入任何参数")
sys.exit()

if sys.argv[1].startswith("-"):
option = sys.argv[1][1:]

利用random生成6位数字加字母随机验证码

import sys
import random

rand=[]

for x in range(6):
y=random.randrange(0,5)
if y == 2 or y == 4:
num=random.randrange(0,9)
rand.append(str(num))
else:
temp=random.randrange(65,91)
c=chr(temp)
rand.append(c)
result="".join(rand)
print(result)

自动化-使用pexpect非交互登陆系统

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.txt', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密码")
ssh.expect('#')

ssh.sendline('ls /home')
ssh.expect('#')

Python-取系统时间

import sys
import time

time_str = time.strftime("日期：%Y-%m-%d",time.localtime())
print(time_str)

time_str= time.strftime("时间：%H:%M",time.localtime())
print(time_str)

psutil-获取内存使用情况

import sys
import os
import psutil

memory_convent = 1024 * 1024
mem =psutil.virtual_memory()

print("内存容量为:"+str(mem.total/(memory_convent))+"MB ")
print("已使用内存:"+str(mem.used/(memory_convent))+"MB ")
print("可用内存:"+str(mem.total/(memory_convent)-mem.used/(1024*1024))+"MB ")
print("buffer容量:"+str(mem.buffers/( memory_convent ))+"MB ")
print("cache容量:"+str(mem.cached/(memory_convent))+"MB ")

Python-通过SNMP协议监控CPU
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import os

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid + '|grep Raw|grep Cpu|grep -v Kernel').read().split(' ')[:-1]
return sn1

def getDate(host):
items = getAllitems(host, '.1.3.6.1.4.1.2021.11')

if name == ' main ':

Python-通过SNMP协议监控系统负载
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import os
import sys

def getAllitems(host, oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')
return sn1

def getload(host,loid):
load_oids = Ƈ.3.6.1.4.1.2021.10.1.3.' + str(loid)
return getAllitems(host,load_oids)[0].split(':')[3]

if name == ' main ':

Python-通过SNMP协议监控内存
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import os

def getAllitems(host, oid):

def getSwapTotal(host):

def getSwapUsed(host):

def getMemTotal(host):

def getMemUsed(host):

if name == ' main ':

Python-通过SNMP协议监控磁盘
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):

def getDate(source,newitem):

def getRealDate(item1,item2,listname):

def caculateDiskUsedRate(host):

if name == ' main ':

Python-通过SNMP协议监控网卡流量
注意：被监控的机器上需要支持snmp协议 yum install -y net-snmp*

import re
import os

def getAllitems(host,oid):
sn1 = os.popen('snmpwalk -v 2c -c public ' + host + ' ' + oid).read().split(' ')[:-1]
return sn1

def getDevices(host):
device_mib = getAllitems(host,'RFC1213-MIB::ifDescr')
device_list = []

def getDate(host,oid):
date_mib = getAllitems(host,oid)[1:]
date = []

if name == ' main ':

Python-实现多级菜单

import os
import sys

ps="[None]->"
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]
flage=1

while True:
ps="[None]->"
temp=input(ps)
if (temp=="test"):
print("test page !!!!")
elif(temp=="user"):
while (flage == 1):
ps="[User]->"
temp1=input(ps)
if(temp1 =="exit"):
flage=0
break
elif(temp1=="show"):
for i in range(len(ip)):
print(i)

Python实现一个没用的东西

import sys

ps="[root@localhost]# "
ip=["192.168.1.1","192.168.1.2","192.168.1.3"]

while True:
temp=input(ps)
temp1=temp.split()

检查各个进程读写的磁盘IO

import sys
import os
import time
import signal
import re

class DiskIO:
def init (self, pname=None, pid=None, reads=0, writes=0):
self.pname = pname
self.pid = pid
self.reads = 0
self.writes = 0

def main():
argc = len(sys.argv)
if argc != 1:
print ("usage: please run this script like [./lyshark.py]")
sys.exit(0)
if os.getuid() != 0:
print ("Error: This script must be run as root")
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
os.system('echo 1 > /proc/sys/vm/block_mp')
print ("TASK PID READ WRITE")
while True:
os.system('dmesg -c > /tmp/diskio.log')
l = []
f = open('/tmp/diskio.log', 'r')
line = f.readline()
while line:
m = re.match(
'^(S+)(d+)(d+): (READ|WRITE) block (d+) on (S+)', line)
if m != None:
if not l:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
continue
found = False
for item in l:
if item.pid == m.group(2):
found = True
if m.group(3) == "READ":
item.reads = item.reads + 1
elif m.group(3) == "WRITE":
item.writes = item.writes + 1
if not found:
l.append(DiskIO(m.group(1), m.group(2)))
line = f.readline()
time.sleep(1)
for item in l:
print ("%-10s %10s %10d %10d" %
(item.pname, item.pid, item.reads, item.writes))
def signal_handler(signal, frame):
os.system('echo 0 > /proc/sys/vm/block_mp')
sys.exit(0)

if name ==" main ":
main()

利用Pexpect实现自动非交互登陆linux

import pexpect
import sys

ssh = pexpect.spawn('ssh [email protected]')
fout = file('sshlog.log', 'w')
ssh.logfile = fout

ssh.expect("[email protected]'s password:")

ssh.sendline("密码")

ssh.expect('#')
ssh.sendline('ls /home')
ssh.expect('#')

利用psutil模块获取系统的各种统计信息

import sys
import psutil
import time
import os

time_str = time.strftime( "%Y-%m-%d", time.localtime( ) )
file_name = "./" + time_str + ".log"

if os.path.exists ( file_name ) == False :
os.mknod( file_name )
handle = open ( file_name , "w" )
else :
handle = open ( file_name , "a" )

if len( sys.argv ) == 1 :
print_type = 1
else :
print_type = 2

def isset ( list_arr , name ) :
if name in list_arr :
return True
else :
return False

print_str = "";

if ( print_type == 1 ) or isset( sys.argv,"mem" ) :
memory_convent = 1024 * 1024
mem = psutil.virtual_memory()
print_str += " 内存状态如下: "
print_str = print_str + " 系统的内存容量为: "+str( mem.total/( memory_convent ) ) + " MB "
print_str = print_str + " 系统的内存以使用容量为: "+str( mem.used/( memory_convent ) ) + " MB "
print_str = print_str + " 系统可用的内存容量为: "+str( mem.total/( memory_convent ) - mem.used/( 1024*1024 )) + "MB "
print_str = print_str + " 内存的buffer容量为: "+str( mem.buffers/( memory_convent ) ) + " MB "
print_str = print_str + " 内存的cache容量为:" +str( mem.cached/( memory_convent ) ) + " MB "

if ( print_type == 1 ) or isset( sys.argv,"cpu" ) :
print_str += " CPU状态如下: "
cpu_status = psutil.cpu_times()
print_str = print_str + " user = " + str( cpu_status.user ) + " "
print_str = print_str + " nice = " + str( cpu_status.nice ) + " "
print_str = print_str + " system = " + str( cpu_status.system ) + " "
print_str = print_str + " idle = " + str ( cpu_status.idle ) + " "
print_str = print_str + " iowait = " + str ( cpu_status.iowait ) + " "
print_str = print_str + " irq = " + str( cpu_status.irq ) + " "
print_str = print_str + " softirq = " + str ( cpu_status.softirq ) + " "
print_str = print_str + " steal = " + str ( cpu_status.steal ) + " "
print_str = print_str + " guest = " + str ( cpu_status.guest ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"disk" ) :
print_str += " 硬盘信息如下: "
disk_status = psutil.disk_partitions()
for item in disk_status :
print_str = print_str + " "+ str( item ) + " "

if ( print_type == 1 ) or isset ( sys.argv,"user" ) :
print_str += " 登录用户信息如下: "
user_status = psutil.users()
for item in user_status :
print_str = print_str + " "+ str( item ) + " "

print_str += "--------------------------------------------------------------- "
print ( print_str )
handle.write( print_str )
handle.close()

import psutil

mem = psutil.virtual_memory()
print mem.total,mem.used,mem
print psutil.swap_memory() # 输出获取SWAP分区信息

cpu = psutil.cpu_stats()
printcpu.interrupts,cpu.ctx_switches

psutil.cpu_times(percpu=True) # 输出每个核心的详细CPU信息
psutil.cpu_times().user # 获取CPU的单项数据 [用户态CPU的数据]
psutil.cpu_count() # 获取CPU逻辑核心数，默认logical=True
psutil.cpu_count(logical=False) # 获取CPU物理核心数

psutil.disk_partitions() # 列出全部的分区信息
psutil.disk_usage('/') # 显示出指定的挂载点情况【字节为单位】
psutil.disk_io_counters() # 磁盘总的IO个数
psutil.disk_io_counters(perdisk=True) # 获取单个分区IO个数

psutil.net_io_counter() 获取网络总的IO，默认参数pernic=False
psutil.net_io_counter(pernic=Ture)获取网络各个网卡的IO

psutil.pids() # 列出所有进程的pid号
p = psutil.Process(2047)
p.name() 列出进程名称
p.exe() 列出进程bin路径
p.cwd() 列出进程工作目录的绝对路径
p.status()进程当前状态[sleep等状态]
p.create_time() 进程创建的时间 [时间戳格式]
p.uids()
p.gids()
p.cputimes() 【进程的CPU时间，包括用户态、内核态】
p.cpu_affinity() # 显示CPU亲缘关系
p.memory_percent() 进程内存利用率
p.meminfo() 进程的RSS、VMS信息
p.io_counters() 进程IO信息，包括读写IO数及字节数
p.connections() 返回打开进程socket的nametples列表
p.num_threads() 进程打开的线程数

import psutil
from subprocess import PIPE
p =psutil.Popen(["/usr/bin/python" ,"-c","print 'helloworld'"],stdout=PIPE)
p.name()
p.username()
p.communicate()
p.cpu_times()

psutil.users() # 显示当前登录的用户，和Linux的who命令差不多

psutil.boot_time() 结果是个UNIX时间戳，下面我们来转换它为标准时间格式，如下：
datetime.datetime.fromtimestamp(psutil.boot_time()) # 得出的结果不是str格式，继续进行转换 datetime.datetime.fromtimestamp(psutil.boot_time()).strftime('%Y-%m-%d%H:%M:%S')

Python生成一个随机密码

import random, string
def GenPassword(length):

if name == ' main ':
print (GenPassword(6))

9. python 执行函数长时间不打日志,检测是否还在运行

pyhon的一个函数在执行I/衫困O参缺派数比如文件读写，socket正在等待数据时是不能干其他事情的，包括打日志。如果想让一个文件准备好读写了或者一个socket有数据可以直接接收时让操作系统通知程序的话，可伏塌贺以试试select库

10. 我的的python语言脚本监控的服务器日志，日志出现错误的时候根据错误关键字进行语音告警。可是最近出现

应该是split后生成的列表的原始超过2个了。看下面的简单的例子就知道了。
其实应或饥该看一下生成后的长度，做个保护，否则像你这种赋值，只要列表长差并度不为2，都会异常。

>>> x=[1,2,3]
>>>虚团迹 a,b=x
Traceback (most recent call last):
File "<interactive input>", line 1, in <mole>
ValueError: too many values to unpack