Mtr exporter

mtr_probe.go

package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os/exec"

    "github.com/gorilla/mux"
)

type MTRResult struct {
    // Define the structure to match MTR JSON output
}

func runMTR(target string) (string, error) {
    cmd := exec.Command("mtr", "--report", "--json", target)
    out, err := cmd.Output()
    if err != nil {
        return "", err
    }
    return string(out), nil
}

func probeHandler(w http.ResponseWriter, r *http.Request) {
    target := r.URL.Query().Get("target")
    if target == "" {
        target = "8.8.8.8"
    }

    result, err := runMTR(target)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "application/json")
    w.Write([]byte(result))
}

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/probe", probeHandler).Methods("GET")
    http.Handle("/", r)
    log.Println("Starting server on :9115")
    log.Fatal(http.ListenAndServe(":9115", nil))
}

Dockerfile

# Start from the official Go image
FROM golang:1.18 as builder

# Set the Current Working Directory inside the container
WORKDIR /app

# Copy go.mod and go.sum files
COPY go.mod go.sum ./

# Download all dependencies. Dependencies will be cached if the go.mod and go.sum files are not changed
RUN go mod download

# Copy the source from the current directory to the Working Directory inside the container
COPY . .

# Build the Go app
RUN go build -o mtr_probe .

# Use a minimal image to run the application
FROM debian:bullseye-slim

# Install MTR
RUN apt-get update && apt-get install -y mtr-tiny

# Copy the pre-built binary file from the previous stage
COPY --from=builder /app/mtr_probe /usr/local/bin/mtr_probe

# Expose port 9115 to the outside world
EXPOSE 9115

# Command to run the executable
CMD ["mtr_probe"]

go.mod

module mtr_probe

go 1.18

require github.com/gorilla/mux v1.8.0

sh

# Build the Docker image
docker build -t mtr-probe .

# Run the Docker container
docker run -d -p 9115:9115 mtr-probe

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [mtr]  # Look for an 'mtr' module in blackbox exporter config.
    static_configs:
      - targets:
        - 'example.com'
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: 127.0.0.1:9115  # MTR prober address

More

# Stage 1: Build the Go application
FROM golang:1.18 as builder

# Set the working directory inside the container
WORKDIR /app

# Copy go.mod and go.sum files
COPY go.mod go.sum ./

# Download all dependencies
RUN go mod download

# Copy the source code
COPY . .

# Build the Go application
RUN go build -o mtr_probe .

# Stage 2: Build the final image
FROM debian:bullseye-slim

# Install MTR and necessary utilities
RUN apt-get update && apt-get install -y mtr-tiny wget ca-certificates

# Install Blackbox Exporter
RUN wget https://github.com/prometheus/blackbox_exporter/releases/download/v0.23.0/blackbox_exporter-0.23.0.linux-amd64.tar.gz \
    && tar -xzf blackbox_exporter-0.23.0.linux-amd64.tar.gz \
    && mv blackbox_exporter-0.23.0.linux-amd64/blackbox_exporter /usr/local/bin/ \
    && rm -rf blackbox_exporter-0.23.0.linux-amd64*

# Copy the Go application binary
COPY --from=builder /app/mtr_probe /usr/local/bin/mtr_probe

# Create a blackbox exporter config
COPY blackbox.yml /etc/blackbox_exporter/config.yml

# Expose ports for both services
EXPOSE 9115 9116

# Start both the Go application and Blackbox Exporter
CMD ["sh", "-c", "mtr_probe & blackbox_exporter --config.file=/etc/blackbox_exporter/config.yml"]

blacbox.yaml

modules:
  http_2xx:
    prober: http
    timeout: 5s
    http:
      valid_http_versions: ["HTTP/1.1", "HTTP/2"]
      valid_status_codes: []  # Defaults to 2xx
      method: GET
  mtr:
    prober: mtr
    timeout: 30s
    mtr:
      targets:
        - 8.8.8.8  # Example target

docker run -d -p 9115:9115 -p 9116:9116 mtr-blackbox-exporter

more2

```package main

import (

   "encoding/json"
   "log"
   "net/http"
   "os/exec"
   "strconv"
   "strings"

"github.com/gorilla/mux"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"

)

// Define the MTRResult struct to match MTR JSON output type MTRResult struct {

   Report struct {
       Hubs []struct {
           Count int     json:"count"
           Loss  float64 json:"Loss%"
           Snt   int     json:"Snt"
           Last  float64 json:"Last"
           Avg   float64 json:"Avg"
           Best  float64 json:"Best"
           Wrst  float64 json:"Wrst"
           StDev float64 json:"StDev"
           Host  string  json:"Host"
       } json:"hubs"
   } json:"report"

}

var (

   // Define Prometheus metrics
   mtrLoss = prometheus.NewGaugeVec(prometheus.GaugeOpts{
       Name: "mtr_loss_percentage",
       Help: "Packet loss percentage reported by MTR",
   }, []string{"host", "target"})

mtrAvg = prometheus.NewGaugeVec(prometheus.GaugeOpts{
    Name: "mtr_avg_latency",
    Help: "Average latency reported by MTR",
}, []string{"host", "target"})

mtrBest = prometheus.NewGaugeVec(prometheus.GaugeOpts{
    Name: "mtr_best_latency",
    Help: "Best latency reported by MTR",
}, []string{"host", "target"})

mtrWrst = prometheus.NewGaugeVec(prometheus.GaugeOpts{
    Name: "mtr_wrst_latency",
    Help: "Worst latency reported by MTR",
}, []string{"host", "target"})

)

func init() {

   // Register Prometheus metrics
   prometheus.MustRegister(mtrLoss)
   prometheus.MustRegister(mtrAvg)
   prometheus.MustRegister(mtrBest)
   prometheus.MustRegister(mtrWrst)

}

func runMTR(target string) (MTRResult, error) {

   cmd := exec.Command("mtr", "--report", "--json", target)
   out, err := cmd.Output()
   if err != nil {
       return MTRResult{}, err
   }

var result MTRResult
err = json.Unmarshal(out, &result)
if err != nil {
    return MTRResult{}, err
}
return result, nil

}

func probeHandler(w http.ResponseWriter, r *http.Request) {

   target := r.URL.Query().Get("target")
   if target == "" {
       target = "8.8.8.8"
   }

result, err := runMTR(target)
if err != nil {
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
}

for _, hub := range result.Report.Hubs {
    host := strings.TrimSpace(hub.Host)
    mtrLoss.WithLabelValues(host, target).Set(hub.Loss)
    mtrAvg.WithLabelValues(host, target).Set(hub.Avg)
    mtrBest.WithLabelValues(host, target).Set(hub.Best)
    mtrWrst.WithLabelValues(host, target).Set(hub.Wrst)
}

w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(result)

}

func main() {

   r := mux.NewRouter()
   r.HandleFunc("/probe", probeHandler).Methods("GET")
   r.Handle("/metrics", promhttp.Handler())

log.Println("Starting server on :9115")
log.Fatal(http.ListenAndServe(":9115", r))

}

```