Menggunakan corak Degupan Jantung di Golang

Melaksanakan Degupan Jantung dalam Go for Application Monitoring

Semasa pengembaraan saya dalam mengimbangi Jurutera Data & Perisian, saya sentiasa mencari sesuatu yang sedikit berbeza dalam GoLang untuk belajar, memahami cara ia berfungsi dan mengaplikasikannya pada perkara yang lebih kompleks daripada beberapa kursus dan artikel tradisional asas yang saya temui di internet . Dalam artikel pendek ini, saya akan melaporkan dan menunjukkan cara saya melaksanakan melalui Go Routines, pakej masa menggunakan Ticker untuk mensimulasikan degupan jantung ("Saya masih hidup") aplikasi, selain penggunaan saluran, dsb.

Bukan berita kepada ramai bahawa adalah amat penting untuk memastikan sesiapa yang memanggil fungsi tertentu tahu sama ada fungsi itu mengambil masa, memproses atau terkunci. Walau bagaimanapun, beberapa istilah lain telah muncul seperti Jejak, Metrik, ketersambungan, dsb., yang telah diperkenalkan dalam aplikasi pemantauan yang dalam kebanyakan kes menggunakan ejen yang dipasang pada pelayan aplikasi yang mengumpul metrik dan menghantarnya ke antara muka yang menggambarkan semua (atau hampir) status permohonan anda. Antara alatan ini, kami mempunyai DataDog, NewRelic, Slack, Grafana, Jaeger, dll.

Apa yang Kita Akan Ada Di Sini?

Sambil saya mengkaji dan berfikir tentang mencipta sesuatu yang pantas dan ringkas yang menangani beberapa konsep Go yang lebih maju, saya mencipta aplikasi yang agak mudah yang menggunakan corak degupan jantung. Sesiapa yang menghubungi saya menerima keputusan dan, pada masa yang sama, maklumat sama ada saya masih aktif atau tidak. Dalam senario yang lebih maju, ini mungkin menarik untuk menyesuaikan apa sebenarnya aplikasi aktif dari segi beberapa kekhususan perniagaan, kerana pelaksanaan mudah Prometheus menyelesaikan kes ini (adakah aplikasi itu aktif? CPU, Memori, goroutine terbuka), tetapi bukan dengan maklum balas serentak dan boleh disesuaikan.

Jam Kod!

Dari segi struktur, saya hanya mencipta tiga fail dalam pakej saya dengan mod go:

• dictionary.go: Mengandungi kamus nama untuk fungsi carian.
• task.go: Tugasan yang mengandungi fungsi mengimbas nama daripada kamus dan, pada masa yang sama, memaklumkan sama ada ia aktif atau tidak melalui pasukan. Ticker's channel beat.
• task_test.go: Melaksanakan ujian unit bagi fungsi yang terdapat dalam task.go untuk melihat kedua-dua respons daripada data kamus dan juga maklum balas sama ada aplikasi masih Naik!

kamus.pergi

Bahagian kod Go ini mentakrifkan pembolehubah yang dipanggil "kamus" iaitu peta yang mengaitkan aksara jenis rune dengan rentetan.

Setiap entri peta ialah kunci (rune) dan nilai (rentetan). Dalam contoh di bawah, kekunci adalah huruf kecil abjad dan nilainya ialah nama yang dikaitkan dengan setiap huruf. Contohnya, huruf ‘a’ dikaitkan dengan nama “airton”, huruf ‘b’ dikaitkan dengan nama “bruno”, dan seterusnya:

package heartbeat

var dicionario = map[rune]string{
    'a': "airton",
    'b': "bruno",
    'c': "carlos",
    'd': "daniel",
    'e': "eduardo",
    'f': "felipe",
    'g': "gustavo",
}

tugas.pergi

Saya menerangkan dengan lebih baik di bawah selepas kod lengkap setiap bahagian kod:

package heartbeat

import (
    "context"
    "fmt"
    "time"
)

func ProcessingTask(
    ctx context.Context, letras chan rune, interval time.Duration,
) (<-chan struct{}, <-chan string) {

    heartbeats := make(chan struct{}, 1)
    names := make(chan string)

    go func() {
        defer close(heartbeats)
        defer close(names)

        beat := time.NewTicker(interval)
        defer beat.Stop()

        for letra := range letras {
            select {
            case <-ctx.Done():
                return
            case <-beat.C:
                select {
                case heartbeats <- struct{}{}:
                default:
                }
            case names <- dicionario[letra]:
                lether := dicionario[letra]
                fmt.Printf("Letra: %s \n", lether)

                time.Sleep(3 * time.Second) // Simula um tempo de espera para vermos o hearbeats
            }
        }
    }()

    return heartbeats, names
}

Mengimport Ketergantungan

package heartbeat

import (
    "context"
    "fmt"
    "time"
)

Di sini saya mempunyai pakej degupan jantung saya yang akan bertanggungjawab untuk melaksanakan fungsi yang menghantar "degupan jantung" pada selang masa tertentu, sambil memproses tugas. Untuk ini, saya memerlukan konteks (Pengurusan Konteks), fmt (untuk pemformatan rentetan) dan masa untuk kawalan masa.

Definisi Fungsi Awal

func ProcessingTask (
    ctx context.Context, letras chan rune, interval time.Duration,
) (<-chan struct{}, <-chan string) {

Ini ialah takrifan fungsi ProcessingTask yang mengambil konteks ctx, saluran huruf (saluran yang menerima aksara Unicode) dan selang masa sebagai argumen. Fungsi ini mengembalikan dua saluran: saluran degupan jantung yang menghantar struct kosong untuk setiap "degupan jantung" dan saluran nama yang menghantar nama huruf yang sepadan dengan setiap aksara yang diterima.

Saluran

heartbeats := make(chan struct{}, 1)
names := make(chan string)

Dua baris ini mencipta dua saluran: degupan jantung ialah saluran penimbal dengan kapasiti satu elemen dan nama ialah saluran tanpa penimbal.

Pergi Rutin yang melakukan pengangkatan berat

go func() 
    defer close(heartbeats)
    defer close(names)

    beat := time.NewTicker(interval)
    defer beat.Stop()

    for letra := range letras {
        select {
        case <-ctx.Done():
            return
        case <-beat.C:
            select {
            case heartbeats <- struct{}{}:
            default:
            }
        case names <- dicionario[letra]:
            lether := dicionario[letra]
            fmt.Printf("Letra: %s \n", lether)

            time.Sleep(3 * time.Second) // Simula um tempo de espera para vermos o hearbeats
        }
    }
}()

return heartbeats, names

Ini ialah goroutine tanpa nama (atau fungsi tanpa nama yang dijalankan dalam urutan baharu) yang melaksanakan logik utama fungsi ProcessingTask. Ia menggunakan gelung untuk julat untuk membaca aksara daripada saluran huruf. Di dalam gelung, gunakan pilih untuk memilih tindakan yang akan dilakukan daripada pilihan yang tersedia:

• case <-ctx.Done(): Jika konteks dibatalkan, fungsi keluar serta-merta, menggunakan penyataan pulangan.
• case <-beat.C: Jika penanda rentak menghantar nilai, goroutine cuba menghantar struct kosong ke saluran degupan jantung menggunakan pilihan dengan lalai kosong.
• nama kes <- kamus[surat]: Jika surat diterima, goroutine mendapatkan nama surat yang sepadan daripada kamus kamus, menghantarnya ke saluran nama, mencetak surat ke skrin menggunakan pakej fmt dan menunggu tiga saat sebelum meneruskan ke watak seterusnya. Penantian simulasi ini adalah supaya kita dapat melihat "degupan jantung" dihantar.

Akhir sekali, fungsi ini mengembalikan degupan jantung dan menamakan saluran.

Menguji Aplikasi

task_test.go

package heartbeat

var dicionario = map[rune]string{
    'a': "airton",
    'b': "bruno",
    'c': "carlos",
    'd': "daniel",
    'e': "eduardo",
    'f': "felipe",
    'g': "gustavo",
}

Di sini saya mencipta ujian unit Go untuk fungsi ProcessingTask yang telah dijelaskan sebelum ini. Fungsi ujian TestProcessingTask mencipta konteks dengan tamat masa 20 saat dan paip aksara Unicode (huruf). Goroutine tanpa nama kemudiannya menghantar lirik ke saluran lirik. Fungsi ProcessingTask kemudiannya dipanggil dengan konteks, saluran aksara Unicode, dan selang masa. Ia mengembalikan dua saluran, saluran degupan jantung dan saluran perkataan.

Kemudian fungsi ujian menjalankan gelung tak terhingga dengan pilihan, yang dibaca daripada tiga saluran: konteks, saluran degupan jantung dan saluran perkataan.

Jika konteks dibatalkan, gelung ujian ditamatkan. Jika degupan jantung diterima, "Permohonan Naik!" dicetak kepada output standard. Jika perkataan diterima, ujian menyemak sama ada perkataan itu terdapat dalam kamus huruf. Jika ia tidak hadir, ujian gagal dan mesej ralat dipaparkan.

Oleh itu, ujian unit ini menguji fungsi ProcessingTask kami, yang menerima aksara daripada satu saluran, menghantar nama huruf ke saluran lain dan mengeluarkan "degupan jantung" semasa berjalan dalam konteks di mana saya menggunakan had masa. Ahhh... dan ia juga menyemak sama ada nama huruf yang dihantar ke saluran perkataan terdapat dalam kamus.

Kesimpulan Saya

Kod Go ini menggambarkan beberapa konsep penting bahasa Go dan ujian unit:

• Konteks
• Gorutin
• Saluran
• Ujian unit (menggunakan pilih untuk memantau berbilang saluran)

Projek penuh pada GitHub saya: https://github.com/AirtonLira/heartbeatsGolang

LinkedIn - Airton Lira Junior

Atas ialah kandungan terperinci Menggunakan corak Degupan Jantung di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!