1. 为什么要做这个东西？
最开始做性能测试，用的是 Loadrunner，服务器大都为 Linux 和 AIX，那时候的监控方法就是 nmon，先执行 nmon，然后导出到 Windows 上来用 excel 分析，操作太麻烦，后来自己折腾了一个基于 Perl 的 nmon 结果文件分析工具，可直接在 Linux，AIX，HPUX 中执行，直接出结果。（可见：nmon 结果分析脚本）
前年的时候，发现性能测试需要监控的机器越来越多，10 台服务器已经是很常见了，这么多机器，执行 nmon 是件很麻烦的事情，且很难与测试场景同步执行。后来接触到 HP 的 SiteScope，发现这个东西真是烂到家了，不过，LR 和 SiteScope 的接口倒可以用一用。后来断断续续开始折腾。目前已经实现了 Linux、AIX、Windows、Android 这几类系统。主要用 python 实现，AIX 中用的 perl，Windows 中是同事帮忙用 C# 写的。

2. 先从安卓开始，先看怎么用。
先配置好 adb 环境，修改脚本中的 app 包名和设备的 udid 信息。然后通过 usb 连接好手机，执行 start 的批处理或者 sh 文件。启动完成后，后台服务开始启动。
可通过 2 种方式来进行访问。
1：通过浏览器。如下图。默认端口 8888，可修改。

2：通过 LoadRunner，如下图。

增加监控项后，通过 LR 的场景，可以实时获取到性能数据。如下图：

3：脚本：
脚本部分使用 python 实现，使用了 bottle 的 web 框架，代码量很小，默认为监听 8888 端口，默认为 5s 获取一次数据，前端的 get 请求一次，返回一次结果（如果 1s get 一次，结果是不变的。），监控项包括了系统的 cpu，内存，app 的 cpu，内存，对应的网络流量（流量为累积值），大部分为通过 proc 目录中的文件进行读取和分析。

#!/usr/bin/env python
# -*- coding: utf-8 -*-

__author__ = 'among,lifeng29@163.com'
__version__ = '1.0,20160322'
__license__ = 'copy left'

import platform
import socket
from time import sleep
from bottle import *


# android app and device info
PKG_NAME = 'com.xxx.xxx'
UDID = 'xxxxxxxxxxx'
# init
interval = 5
port = 8888
socket.setdefaulttimeout(10)

pt_name = platform.platform()
if pt_name.startswith('Windows'):
    GREP = 'findstr'
else:
    GREP = 'grep'

# start
cpu_temp = {"idle": None, "user": None, "system": None, "iowait": None, "total": None, "cpu_app": None}
cpu_result = {"cpu_Total": None, "cpu_User": None, "cpu_Sys": None, "cpu_iowait": None, "cpu_app": None}
mem_result = {"MemTotal": None, "MemUsage": None, "Buffers": None, "Cached": None, "MemUsage_pct": None}
other_result = {"Native_heap": None, "Dalvik_heap": None, "Mem_app": None, "Network_rx": None, "Network_tx": None,
                "Network_all": None}
pkg_info = {"pkg_name": PKG_NAME, "pid": None, "uid": None, "userId": None, "UDID": UDID}


# function start
# ex_cmd
def ex_cmd(cmd):
    res = list()
    try:
        fh = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
        fh.wait()
        for line in fh.stdout.readlines():
            line = line.decode().strip()
            if line != '':
                res.append(line)
        fh.stdout.close()
    except Exception as ex:
        print('run cmd exception: %s' % ex)
        res.append('error')
    return res


# get package pid ...
def get_pkg():
    global pkg_info
    pid_file = ex_cmd('adb -s %s shell ps|%s %s' % (pkg_info['UDID'], GREP, pkg_info['pkg_name']))
    if len(pid_file) > 0:
        pkg_info['uid'], pkg_info['pid'] = pid_file[0].split()[0:2]
    else:
        pkg_info['pid'] = None
        pkg_info['uid'] = None
    # print(pkg_info)


# get proc file
def Read_Proc(file):
    proc_file = ex_cmd('adb -s %s shell cat /proc/%s' % (pkg_info['UDID'], file))
    return proc_file


# get memory
def And_Memory():
    global mem_result
    Proc_MemInfo = Read_Proc('meminfo')
    if len(Proc_MemInfo) == 0:
        for x in mem_result:
            mem_result[x] = None
        return None
    Memory = dict()
    for i in Proc_MemInfo:
        Memory[i.split()[0][0:-1]] = int(i.split()[1])
    MemTotal = Memory['MemTotal']
    MemFree = Memory['MemFree']
    Buffers = Memory['Buffers']
    Cached = Memory['Cached']
    # memusage calc
    MemUsage = MemTotal - MemFree - Buffers - Cached
    # result value
    mem_result['MemTotal'] = MemTotal
    mem_result['MemUsage'] = MemUsage
    mem_result['Buffers'] = Buffers
    mem_result['Cached'] = Cached
    mem_result['MemUsage_pct'] = ('%.3f' % (float(MemUsage) * 100 / MemTotal))


# get system cpu
def And_Cpu():
    global cpu_result
    global cpu_temp
    Cpu_data = Read_Proc('stat')
    if len(Cpu_data) == 0:
        for x in cpu_temp:
            cpu_temp[x] = None
        for x in cpu_result:
            cpu_result[x] = None
        return None
    Cpu_data = Cpu_data[0].split()
    app_cpu1 = None
    if pkg_info['pid'] is not None:
        Cpu_app_data = Read_Proc('%s/stat' % pkg_info['pid'])[0].split()
        if len(Cpu_app_data) > 20:
            app_cpu1 = float(Cpu_app_data[13]) + float(Cpu_app_data[14]) + float(Cpu_app_data[15]) + float(
                Cpu_app_data[16])
    idle = float(Cpu_data[4])
    user = float(Cpu_data[1]) + float(Cpu_data[2])
    system = float(Cpu_data[3]) + float(Cpu_data[6]) + float(Cpu_data[7])
    iowait = float(Cpu_data[5])
    total = idle + user + system + iowait
    if cpu_temp['idle'] is not None:
        cpu_result_temp = dict()
        cpu_per = total - cpu_temp['total']
        cpu_result_temp['cpu_User'] = str("%.3f" % ((user - cpu_temp['user']) / cpu_per * 100))
        cpu_result_temp['cpu_Sys'] = str("%.3f" % ((system - cpu_temp['system']) / cpu_per * 100))
        cpu_result_temp['cpu_iowait'] = str("%.3f" % ((iowait - cpu_temp['iowait']) / cpu_per * 100))
        cpu_result_temp['cpu_Total'] = str("%.3f" % ((cpu_per - idle + cpu_temp['idle']) / cpu_per * 100))
        if cpu_temp['cpu_app'] is not None and app_cpu1 is not None:
            cpu_result_temp['cpu_app'] = str("%.3f" % ((app_cpu1 - cpu_temp['cpu_app']) / cpu_per * 100))
            if float(cpu_result_temp['cpu_app']) < 0:
                cpu_result_temp['cpu_app'] = None
        else:
            cpu_result_temp['cpu_app'] = None
        if float(cpu_result_temp['cpu_Total']) < 0 or float(cpu_result_temp['cpu_User']) < 0 or float(
                cpu_result_temp['cpu_Sys']) < 0:
            # print('zero###############################')
            return None
        else:
            cpu_result = cpu_result_temp
    cpu_temp['idle'] = idle
    cpu_temp['user'] = user
    cpu_temp['system'] = system
    cpu_temp['iowait'] = iowait
    cpu_temp['total'] = total
    cpu_temp['cpu_app'] = app_cpu1


# get other
def And_Other():
    global other_result
    if pkg_info['pid'] is None:
        for x in other_result:
            other_result[x] = None
    else:
        global mem_result
        # mem calc
        ad_mem_info = ex_cmd('adb -s %s shell dumpsys meminfo %s' % (pkg_info['UDID'], pkg_info['pkg_name']))
        if len(ad_mem_info) > 5:
            for info in ad_mem_info:
                info = info.split()
                if info[0] == 'Native':
                    if info[1].isdigit():
                        other_result['Native_heap'] = info[1]
                    elif info[1] == 'Heap':
                        other_result['Native_heap'] = info[2]
                elif info[0] == 'Dalvik':
                    if info[1].isdigit():
                        other_result['Dalvik_heap'] = info[1]
                    elif info[1] == 'Heap':
                        other_result['Dalvik_heap'] = info[2]
                elif info[0] == 'TOTAL':
                    other_result['Mem_app'] = info[1]
                    break
            # net user calc
            net_user_info = ex_cmd(
                'adb -s %s shell cat /proc/net/xt_qtaguid/stats |%s %s' % (pkg_info['UDID'], GREP, pkg_info["userId"]))
            if len(net_user_info) > 0:
                rx_b = 0
                tx_b = 0
                for xx in net_user_info:
                    all_net = xx.split()
                    rx_b += int(all_net[5])
                    tx_b += int(all_net[7])
                rxtx = rx_b + tx_b
                other_result['Network_rx'] = rx_b
                other_result['Network_tx'] = tx_b
                other_result['Network_all'] = rxtx


def mon_run():
    while True:
        thrs = list()
        t0 = threading.Thread(target=get_pkg)
        t0.start()
        thrs.append(t0)
        t1 = threading.Thread(target=And_Memory)
        t1.start()
        thrs.append(t1)
        t2 = threading.Thread(target=And_Cpu)
        t2.start()
        thrs.append(t2)
        t3 = threading.Thread(target=And_Other)
        t3.start()
        thrs.append(t3)
        for t in thrs:
            t.join()
        sleep(interval)


def mon_page():
    return template('android', MemTotal=mem_result['MemTotal'], MemUsage=mem_result['MemUsage'],
                    Buffers=mem_result['Buffers'], Cached=mem_result['Cached'],
                    MemUsage_pct=mem_result['MemUsage_pct'], Native_heap=other_result['Native_heap'],
                    Dalvik_heap=other_result['Dalvik_heap'], Mem_app=other_result['Mem_app'],
                    cpu_Total=cpu_result['cpu_Total'], cpu_User=cpu_result['cpu_User'], cpu_Sys=cpu_result['cpu_Sys'],
                    cpu_iowait=cpu_result['cpu_iowait'], cpu_app=cpu_result['cpu_app'],
                    Network_rx=other_result['Network_rx'], Network_tx=other_result['Network_tx'],
                    Network_all=other_result['Network_all'])


# get app userid

userid_info = ex_cmd('adb -s %s shell dumpsys package %s|%s userId' % (pkg_info['UDID'], PKG_NAME, GREP))

if len(userid_info) > 0:
    tpinfo = userid_info[0].split()
    pkg_info["userId"] = tpinfo[0].split('=')[1]

th_all = threading.Thread(target=mon_run)
th_all.setDaemon(True)
th_all.start()

app = Bottle()


# monitor
@app.route('/SiteScope/cgi/go.exe/SiteScope')
@app.route('/monitor')
def monitor():
    return mon_page()


run(app=app, host='0.0.0.0', port=port, reloader=False, quiet=True, debug=True)

代码写的比较烂，算是功能实现了。
以上仅是针对安卓的代码，其他系统的都与此类似。

协议本身比较简单，就是通过 http 协议传输 xml 格式的数据，如果自己搞个前端，可以做出更好的样式。
通过 LR 也可以在测试过程中同步记录数据到 LR 的结果中。

3. 其他平台的实现
AIX 中，基于 Perl（AIX 中不预装 python），使用方式一致。
Linux，基于 Python，使用方式一致。
Windows，同事帮忙基于 C# 实现的，可做为系统服务，使用方式一致。

全部的代码在点击这里

4. 效果
目前满足了我们性能测试过程中，大量服务器端监控的需求，系统监控的工作量大大降低，对于其他工具，如 jmeter，有熟悉看能否集成使用。

代码中可能还存在一些 bug，欢迎大家讨论。