Linux下Python多进程代理流量分进程监控方案咨询

方案一：代码层直接统计（最准确，推荐） #

在每个进程内部对HTTP请求/响应的字节数做精确统计，完全避免外部工具的误差问题。

以requests库为例，可封装自定义HTTPAdapter拦截请求和响应，累计收发字节：

import requests
import os
from requests.adapters import HTTPAdapter

class TrafficStatsAdapter(HTTPAdapter):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # 进程内独立的统计变量
        self.sent_bytes = 0
        self.recv_bytes = 0

    def send(self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None):
        # 统计请求字节：请求行+请求头+请求体
        request_bytes = len(request.method) + len(request.url) + 2  # 含空格和换行符
        request_bytes += sum(len(k) + len(v) + 2 for k, v in request.headers.items())
        if request.body:
            request_bytes += len(request.body)
        self.sent_bytes += request_bytes

        # 发送请求并统计响应字节
        response = super().send(request, stream, timeout, verify, cert, proxies)
        if not stream:
            self.recv_bytes += len(response.content) + sum(len(k) + len(v) + 2 for k, v in response.headers.items())
        return response

# 子进程执行逻辑
def worker_process(proxy_url):
    session = requests.Session()
    adapter = TrafficStatsAdapter()
    session.mount("http://", adapter)
    session.mount("https://", adapter)

    # 调用第三方API示例
    response = session.get("https://third-party-api.example.com/endpoint", 
                          proxies={"http": proxy_url, "https": proxy_url})
    
    # 输出当前进程流量统计
    print(f"进程{os.getpid()} 发送: {adapter.sent_bytes}字节, 接收: {adapter.recv_bytes}字节")

如果是流式响应，需改为逐块读取并累加字节数，确保统计完整。

方案二：读取Linux /proc文件系统获取进程流量 #

利用系统自带的/proc文件系统，直接读取每个进程的网络收发数据，无需额外工具，准确性优于nethogs。

每个进程的网络统计信息位于/proc/[pid]/net/dev，可通过以下代码读取：

import os
import multiprocessing
import time

def get_process_traffic(pid):
    dev_path = f"/proc/{pid}/net/dev"
    if not os.path.exists(dev_path):
        return (0, 0)
    total_recv = 0
    total_sent = 0
    with open(dev_path, "r") as f:
        # 跳过前两行表头
        lines = f.readlines()[2:]
        for line in lines:
            parts = line.strip().split()
            if len(parts) >= 10:
                total_recv += int(parts[1])
                total_sent += int(parts[9])
    return (total_recv, total_sent)

# 主进程定期监控子进程流量
def monitor_processes(processes):
    while any(p.is_alive() for p in processes):
        for p in processes:
            if p.is_alive():
                recv, sent = get_process_traffic(p.pid)
                print(f"进程{p.pid} 累计接收: {recv}字节, 累计发送: {sent}字节")
        time.sleep(5)

注意：该统计包含进程的所有网络流量，若进程还有其他网络操作，需结合代理的IP/端口做过滤。

方案三：用iptables标记并统计进程流量 #

需要root权限，通过iptables规则匹配进程PID，单独统计每个进程的代理流量。

1. 创建自定义iptables链：

iptables -N PROCESS_TRAFFIC
iptables -A OUTPUT -j PROCESS_TRAFFIC

2. 为目标进程添加规则（替换[PID]和代理地址）：

iptables -A PROCESS_TRAFFIC -p tcp --dport 8080 -d 192.168.1.100 -m owner --pid-owner [PID] -j ACCEPT

3. 查看该进程的流量统计：

iptables -nvL PROCESS_TRAFFIC | grep [PID]

4. 进程结束后删除对应规则：

iptables -D PROCESS_TRAFFIC -p tcp --dport 8080 -d 192.168.1.100 -m owner --pid-owner [PID] -j ACCEPT

可在Python代码中通过subprocess调用iptables命令，实现规则的动态管理。

内容的提问来源于stack exchange，提问作者Роман Денисенко