Bagaimana untuk melaksanakan pemantauan proses di golang

Dalam pembangunan dan operasi serta penyelenggaraan, kami selalunya perlu memantau proses untuk memastikan ia dapat berjalan seperti biasa dan masalah dapat dikesan dan ditangani tepat pada masanya apabila ia berlaku. Dalam artikel ini, kami akan memperkenalkan cara menggunakan bahasa Go untuk melaksanakan pemantauan proses, membantu anda memahami dan menggunakan teknologi pemantauan dengan lebih baik.

1. Prinsip asas pemantauan proses

Pemantauan proses terutamanya merujuk kepada teknologi untuk memantau, mengawal dan pengendalian pengecualian bagi status berjalan aplikasi. Dalam istilah orang awam, ia adalah untuk menggunakan kaedah pemantauan tertentu untuk memantau status berjalan program dalam masa nyata, sambil memastikan program itu dilaksanakan secara normal dan boleh mengendalikan ralat tepat pada masanya.

Dalam pemantauan proses, kaedah pemantauan yang paling biasa digunakan ialah mekanisme degupan jantung. Mekanisme degupan jantung yang dipanggil adalah untuk menghantar mesej secara berterusan ke luar semasa program dijalankan untuk menunjukkan status operasi normalnya. Dan kami menentukan sama ada program itu sihat dengan menangkap dan menghuraikan mesej ini. Sebaik sahaja keabnormalan program ditemui, ia akan diproses dengan sewajarnya untuk memastikan operasi normal sistem.

2. Idea pelaksanaan pemantauan proses dalam golang

Dalam bahasa Go, kita boleh menggunakan beberapa pakej siap sedia untuk melaksanakan pemantauan proses. Langkah pelaksanaan khusus adalah seperti berikut:

1 Dapatkan semua maklumat proses

Kita boleh menggunakan pakej proses dalam pakej psutil untuk mendapatkan maklumat yang berkaitan tentang semua proses dalam sistem. Mula-mula, kita perlu memperkenalkan pakej:

import (
    "github.com/shirou/gopsutil/process"
)

Kemudian, dapatkan semua proses dalam sistem dengan memanggil process.Processes() function:

processes, err := process.Processes()
if err != nil {
    log.Fatalf("failed to get all processes: %v", err)
}

Fungsi ini mengembalikan a hirisan proses, setiap elemen adalah struktur yang mengandungi maklumat proses. Untuk struktur tertentu, sila rujuk dokumentasi rasmi psutil.

2. Tapis proses yang perlu dipantau

Untuk memantau proses tertentu, kita perlu mencari proses yang kita minati di antara semua proses dan merekodkan pid mereka. Di sini kita boleh menggunakan beberapa penapis bersyarat untuk menapis dengan cepat proses yang perlu dipantau. Sebagai contoh, kami boleh menapis proses yang kami perlukan berdasarkan nama proses, ID proses dan syarat lain. Mengambil nama proses sebagai contoh, kodnya adalah seperti berikut:

targetProcessName := "myApp"
targetPidList := make([]int32, 0)

for _, proc := range processes {
    name, err := proc.Name()
    if err != nil || name != targetProcessName {
        continue
    }
    pid := proc.Pid
    targetPidList = append(targetPidList, pid)
    log.Printf("find target process %s, pid = %d\n", name, pid)
}

3. Lakukan pengesanan degupan jantung pada proses yang perlu dipantau

Untuk proses yang perlu dipantau. , kita boleh menghantar mesej degupan jantung kepadanya Tentukan sama ada ia beroperasi secara normal. Secara khusus, kita boleh membuat pertimbangan dengan membaca CPU dan penggunaan memorinya. Jika anda mendapati penggunaan CPU dan memori yang tidak normal, anda boleh berfikir bahawa terdapat masalah dengan proses tersebut.

Untuk melaksanakan pengesanan degupan jantung, kita boleh menggunakan goroutine untuk membaca secara berkala status proses yang ditentukan dan merekodkannya. Kod pelaksanaan khusus adalah seperti berikut:

type ProcessState struct {
    CpuPercent    float64
    MemResident   uint64
    MemVirtual    uint64
    MemSwap       uint64
}

func checkProcessState(targetPid int32, stateChan chan<- ProcessState) {
    ticker := time.NewTicker(5 * time.Second)
    for {
        select {
        case <-ticker.C:
            proc, err := process.NewProcess(targetPid)
            if err != nil {
                log.Printf("failed to get process %d: %v", targetPid, err)
                continue
            }
            cpuPercent, err := proc.CPUPercent()
            if err != nil {
                log.Printf("failed to get cpu percent for process %d: %v", targetPid, err)
                continue
            }
            memInfo, err := proc.MemoryInfo()
            if err != nil {
                log.Printf("failed to get memory info for process %d: %v", targetPid, err)
                continue
            }
            state := ProcessState{
                CpuPercent:  cpuPercent,
                MemResident: memInfo.RSS,
                MemVirtual:  memInfo.VMS,
                MemSwap:     memInfo.Swap,
            }
            stateChan <- state
        }
    }
}

Dalam kod di atas, kami mula-mula menggunakan pemasa ticker untuk menyemak status proses yang ditentukan setiap lima saat. Semasa proses pengesanan, kami memperoleh pengendalian proses pid yang ditentukan melalui fungsi proses.NewProcess(), dan menggunakan fungsi yang disediakan untuk mendapatkan penggunaan CPU dan penggunaan memori. Simpan maklumat ini dalam struktur yang ditakrifkan di atas dan hantarkannya ke luar melalui stateChan.

3. Contoh kod pemantauan proses golang lengkap

Berdasarkan idea dan kod pelaksanaan di atas, kita boleh menulis contoh kod pemantauan proses golang yang lengkap. Kod lengkap adalah seperti berikut:

package main

import (
    "fmt"
    "github.com/shirou/gopsutil/process"
    "log"
    "time"
)

type ProcessState struct {
    CpuPercent    float64
    MemResident   uint64
    MemVirtual    uint64
    MemSwap       uint64
}

func main() {
    targetProcessName := "myApp"
    targetPidList := make([]int32, 0)
    processes, err := process.Processes()
    if err != nil {
        log.Fatalf("failed to get all processes: %v", err)
    }
    for _, proc := range processes {
        name, err := proc.Name()
        if err != nil || name != targetProcessName {
            continue
        }
        pid := proc.Pid
        targetPidList = append(targetPidList, pid)
        log.Printf("find target process %s, pid = %d\n", name, pid)
    }
    stateChan := make(chan ProcessState)
    for _, pid := range targetPidList {
        go checkProcessState(pid, stateChan)
    }
    for {
        select {
        case state := <-stateChan:
            if state.CpuPercent > 100.0 || state.MemSwap > 0 || state.MemVirtual > 2*state.MemResident {
                log.Printf("process is not healthy: %+v\n", state)
            } else {
                log.Printf("process is healthy: %+v\n", state)
            }
        }
    }
}

func checkProcessState(targetPid int32, stateChan chan<- ProcessState) {
    ticker := time.NewTicker(5 * time.Second)
    for {
        select {
        case <-ticker.C:
            proc, err := process.NewProcess(targetPid)
            if err != nil {
                log.Printf("failed to get process %d: %v", targetPid, err)
                continue
            }
            cpuPercent, err := proc.CPUPercent()
            if err != nil {
                log.Printf("failed to get cpu percent for process %d: %v", targetPid, err)
                continue
            }
            memInfo, err := proc.MemoryInfo()
            if err != nil {
                log.Printf("failed to get memory info for process %d: %v", targetPid, err)
                continue
            }
            state := ProcessState{
                CpuPercent:  cpuPercent,
                MemResident: memInfo.RSS,
                MemVirtual:  memInfo.VMS,
                MemSwap:     memInfo.Swap,
            }
            stateChan <- state
        }
    }
}

Dalam contoh ini, kita mula-mula mencari proses yang perlu kita pantau, dan memulakan goroutine untuk setiap proses untuk mengesan statusnya secara kerap. Program ini secara berterusan menerima mesej status daripada goroutine daripada chan, dan menentukan sama ada program berjalan secara normal berdasarkan status. Jika keabnormalan proses ditemui, gesaan yang sepadan akan diberikan melalui log.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan bahasa Go untuk melaksanakan pemantauan proses, terutamanya dengan memanggil API yang disediakan dalam pakej psutil dan menggunakan goroutine untuk pengesanan biasa. Pemantauan proses membolehkan kami mengawal status berjalan aplikasi dengan lebih baik dan dengan segera mengendalikan pengecualian apabila program berlaku, membantu kami melaksanakan pembangunan dan operasi dan penyelenggaraan sistem dengan lebih baik.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pemantauan proses di golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!