Upstream
/
adguard-exporter
mirror of https://github.com/ebrianne/adguard-exporter.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added more metrics. HTTP protocol only supported

This commit is contained in:
Eldwan Brianne 2020-11-02 18:18:08 +01:00
parent 7cbc8b8893
commit 86c12b3921
4 changed files with 217 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
internal/adguard/client.go
View File

@ -1,113 +1,123 @@
package adguard package adguard
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"log" "log"
"net/http" "net/http"
"os" "os"
"time" "time"
b64 "encoding/base64"
"github.com/ebrianne/adguard-exporter/internal/metrics" "github.com/ebrianne/adguard-exporter/internal/metrics"
) )
var ( var (
statsURLPattern = "%s://%s:%d/control/stats" statsURLPattern = "%s://%s:%d/control/stats"
) )
// Client struct is a AdGuard client to request an instance of a AdGuard ad blocker. // Client struct is a AdGuard client to request an instance of a AdGuard ad blocker.
type Client struct { type Client struct {
httpClient http.Client httpClient http.Client
interval time.Duration interval time.Duration
protocol string protocol string
hostname string hostname string
port uint16 port uint16
username string b64password string
password string
sessionID string
} }
// NewClient method initializes a new AdGuard client. // NewClient method initializes a new AdGuard client.
func NewClient(protocol, hostname string, port uint16, username, password string, interval time.Duration) *Client { func NewClient(protocol, hostname string, port uint16, b64password string, interval time.Duration) *Client {
if protocol != "http" && protocol != "https" { if protocol != "http" {
log.Printf("protocol %s is invalid. Must be http or https.", protocol) log.Printf("protocol %s is invalid. Must be http.", protocol)
os.Exit(1) os.Exit(1)
} }
return &Client{ return &Client{
protocol: protocol, protocol: protocol,
hostname: hostname, hostname: hostname,
port: port, port: port,
username: username, b64password: b64password,
password: password, interval: interval,
interval: interval, httpClient: http.Client{},
httpClient: http.Client{ }
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse
},
},
}
} }
// Scrape method authenticates and retrieves statistics from AdGuard JSON API // Scrape method authenticates and retrieves statistics from AdGuard JSON API
// and then pass them as Prometheus metrics. // and then pass them as Prometheus metrics.
func (c *Client) Scrape() { func (c *Client) Scrape() {
for range time.Tick(c.interval) { for range time.Tick(c.interval) {
stats := c.getStatistics() stats := c.getStatistics()
c.setMetrics(stats) c.setMetrics(stats)
log.Printf("New tick of statistics: %s", stats.ToString()) log.Printf("New tick of statistics: %s", stats.ToString())
} }
} }
func (c *Client) setMetrics(stats *Stats) { func (c *Client) setMetrics(stats *Stats) {
metrics.AvgProcessingTime.WithLabelValues(c.hostname).Set(float64(stats.AvgProcessingTime)) metrics.AvgProcessingTime.WithLabelValues(c.hostname).Set(float64(stats.AvgProcessingTime))
metrics.DnsQueries.WithLabelValues(c.hostname).Set(float64(stats.DnsQueries))
metrics.BlockedFiltering.WithLabelValues(c.hostname).Set(float64(stats.BlockedFiltering))
metrics.ParentalFiltering.WithLabelValues(c.hostname).Set(float64(stats.ParentalFiltering))
metrics.SafeBrowsingFiltering.WithLabelValues(c.hostname).Set(float64(stats.SafeBrowsingFiltering))
metrics.SafeSearchFiltering.WithLabelValues(c.hostname).Set(float64(stats.SafeSearchFiltering))
for l := range stats.TopQueries {
for domain, value := range stats.TopQueries[l] {
metrics.TopQueries.WithLabelValues(c.hostname, domain).Set(float64(value))
}
}
for l := range stats.TopBlocked {
for domain, value := range stats.TopBlocked[l] {
metrics.TopBlocked.WithLabelValues(c.hostname, domain).Set(float64(value))
}
}
for l := range stats.TopClients {
for source, value := range stats.TopClients[l] {
metrics.TopClients.WithLabelValues(c.hostname, source).Set(float64(value))
}
}
} }
func (c *Client) getStatistics() *Stats { func (c *Client) getStatistics() *Stats {
var stats Stats var stats Stats
statsURL := fmt.Sprintf(statsURLPattern, c.protocol, c.hostname, c.port) statsURL := fmt.Sprintf(statsURLPattern, c.protocol, c.hostname, c.port)
req, err := http.NewRequest("GET", statsURL, nil) req, err := http.NewRequest("GET", statsURL, nil)
if err != nil { if err != nil {
log.Fatal("An error has occured when creating HTTP statistics request", err) log.Fatal("An error has occured when creating HTTP statistics request ", err)
} }
if c.isUsingPassword() { if c.isUsingPassword() {
c.authenticateRequest(req) c.authenticateRequest(req)
} }
resp, err := c.httpClient.Do(req) resp, err := c.httpClient.Do(req)
if err != nil { if err != nil {
log.Printf("An error has occured during login to Adguard: %v", err) log.Printf("An error has occured during login to Adguard: %v", err)
} }
body, err := ioutil.ReadAll(resp.Body) body, err := ioutil.ReadAll(resp.Body)
if err != nil { if err != nil {
log.Println("Unable to read Adguard statistics HTTP response", err) log.Println("Unable to read Adguard statistics HTTP response", err)
} }
err = json.Unmarshal(body, &stats) err = json.Unmarshal(body, &stats)
if err != nil { if err != nil {
log.Println("Unable to unmarshal Adguard statistics to statistics struct model", err) log.Println("Unable to unmarshal Adguard statistics to statistics struct model", err)
} }
return &stats return &stats
}
func (c *Client) basicAuth() string {
auth := c.username + ":" + c.password
return base64.StdEncoding.EncodeToString([]byte(auth))
} }
func (c *Client) isUsingPassword() bool { func (c *Client) isUsingPassword() bool {
return len(c.password) > 0 return len(c.b64password) > 0
} }
func (c *Client) authenticateRequest(req *http.Request) { func (c *Client) authenticateRequest(req *http.Request) {
req.Header.Add("Authorization", "Basic " + c.basicAuth()) req.Header.Add("Authorization", "Basic " + c.b64password)
} }

14
internal/adguard/model.go
View File

@ -3,14 +3,22 @@ package adguard
import "fmt" import "fmt"
const ( const (
enabledStatus = "enabled" enabledStatus = "enabled"
) )
type Stats struct { type Stats struct {
AvgProcessingTime float64 `json:"avg_processing_time"` AvgProcessingTime float64 `json:"avg_processing_time"`
DnsQueries int `json:"num_dns_queries"`
BlockedFiltering int `json:"num_blocked_filtering"`
ParentalFiltering int `json:"num_replaced_parental"`
SafeBrowsingFiltering int `json:"num_replaced_safebrowsing"`
SafeSearchFiltering int `json:"num_replaced_safesearch"`
TopQueries []map[string]int `json:"top_queried_domains"`
TopBlocked []map[string]int `json:"top_blocked_domains"`
TopClients []map[string]int `json:"top_clients"`
} }
// ToString method returns a string of the current statistics struct. // ToString method returns a string of the current statistics struct.
func (s *Stats) ToString() string { func (s *Stats) ToString() string {
return fmt.Sprintf("Average Processing Time %d s", s.AvgProcessingTime) return fmt.Sprintf("%d ads blocked / %d total DNS queries", s.BlockedFiltering, s.DnsQueries)
} }

106
internal/metrics/metrics.go
View File

@ -1,28 +1,108 @@
package metrics package metrics
import ( import (
"log" "log"
"github.com/prometheus/client_golang/prometheus" "github.com/prometheus/client_golang/prometheus"
) )
var ( var (
AvgProcessingTime = prometheus.NewGaugeVec( AvgProcessingTime = prometheus.NewGaugeVec(
prometheus.GaugeOpts{ prometheus.GaugeOpts{
Name: "avg_processing_time", Name: "avg_processing_time",
Namespace: "adguard", Namespace: "adguard",
Help: "This represent the average processing time for a DNS query in s", Help: "This represent the average processing time for a DNS query in s",
}, },
[]string{"hostname"}, []string{"hostname"},
) )
DnsQueries = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "num_dns_queries",
Namespace: "adguard",
Help: "Number of DNS queries",
},
[]string{"hostname"},
)
BlockedFiltering = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "num_blocked_filtering",
Namespace: "adguard",
Help: "This represent the number of domains blocked",
},
[]string{"hostname"},
)
ParentalFiltering = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "num_replaced_parental",
Namespace: "adguard",
Help: "This represent the number of domains blocked (parental)",
},
[]string{"hostname"},
)
SafeBrowsingFiltering = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "num_replaced_safebrowsing",
Namespace: "adguard",
Help: "This represent the number of domains blocked (safe browsing)",
},
[]string{"hostname"},
)
SafeSearchFiltering = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "num_replaced_safesearch",
Namespace: "adguard",
Help: "This represent the number of domains blocked (safe search)",
},
[]string{"hostname"},
)
TopQueries = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "top_queried_domains",
Namespace: "adguard",
Help: "This represent the top queried domains",
},
[]string{"hostname", "domain"},
)
TopBlocked = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "top_blocked_domains",
Namespace: "adguard",
Help: "This represent the top bloacked domains",
},
[]string{"hostname", "domain"},
)
TopClients = prometheus.NewGaugeVec(
prometheus.GaugeOpts{
Name: "top_clients",
Namespace: "adguard",
Help: "This represent the top clients",
},
[]string{"hostname", "client"},
)
) )
// Init initializes all Prometheus metrics made available by AdGuard exporter. // Init initializes all Prometheus metrics made available by AdGuard exporter.
func Init() { func Init() {
initMetric("avg_processing_time", AvgProcessingTime) initMetric("avg_processing_time", AvgProcessingTime)
initMetric("num_dns_queries", DnsQueries)
initMetric("num_blocked_filtering", BlockedFiltering)
initMetric("num_replaced_parental", ParentalFiltering)
initMetric("num_replaced_safebrowsing", SafeBrowsingFiltering)
initMetric("num_replaced_safesearch", SafeSearchFiltering)
initMetric("top_queried_domains", TopQueries)
initMetric("top_blocked_domains", TopBlocked)
initMetric("top_clients", TopClients)
} }
func initMetric(name string, metric *prometheus.GaugeVec) { func initMetric(name string, metric *prometheus.GaugeVec) {
prometheus.MustRegister(metric) prometheus.MustRegister(metric)
log.Printf("New Prometheus metric registered: %s", name) log.Printf("New Prometheus metric registered: %s", name)
} }

61
main.go
View File

@ -1,53 +1,64 @@
package main package main
import ( import (
"fmt" "fmt"
"os" "os"
"os/signal" "os/signal"
"syscall" "syscall"
"time" "time"
"encoding/base64"
"github.com/ebrianne/adguard-exporter/config" "github.com/ebrianne/adguard-exporter/config"
"github.com/ebrianne/adguard-exporter/internal/metrics" "github.com/ebrianne/adguard-exporter/internal/metrics"
"github.com/ebrianne/adguard-exporter/internal/adguard" "github.com/ebrianne/adguard-exporter/internal/adguard"
"github.com/ebrianne/adguard-exporter/internal/server" "github.com/ebrianne/adguard-exporter/internal/server"
) )
const ( const (
name = "adguard-exporter" name = "adguard-exporter"
) )
var ( var (
s *server.Server s *server.Server
) )
func main() { func main() {
conf := config.Load() conf := config.Load()
metrics.Init() metrics.Init()
initAdguardClient(conf.AdguardProtocol, conf.AdguardHostname, conf.AdguardPort, conf.AdguardUsername, conf.AdguardPassword, conf.Interval) initAdguardClient(conf.AdguardProtocol, conf.AdguardHostname, conf.AdguardPort, conf.AdguardUsername, conf.AdguardPassword, conf.Interval)
initHttpServer(conf.Port) initHttpServer(conf.Port)
handleExitSignal() handleExitSignal()
}
func basicAuth(username, password string) string {
auth := username + ":" + password
return base64.StdEncoding.EncodeToString([]byte(auth))
} }
func initAdguardClient(protocol, hostname string, port uint16, username, password string, interval time.Duration) { func initAdguardClient(protocol, hostname string, port uint16, username, password string, interval time.Duration) {
client := adguard.NewClient(protocol, hostname, port, username, password, interval) b64password := ""
go client.Scrape() if len(username) > 0 && len(password) > 0 {
b64password = basicAuth(username, password)
}
client := adguard.NewClient(protocol, hostname, port, b64password, interval)
go client.Scrape()
} }
func initHttpServer(port string) { func initHttpServer(port string) {
s = server.NewServer(port) s = server.NewServer(port)
go s.ListenAndServe() go s.ListenAndServe()
} }
func handleExitSignal() { func handleExitSignal() {
stop := make(chan os.Signal, 1) stop := make(chan os.Signal, 1)
signal.Notify(stop, os.Interrupt, syscall.SIGTERM) signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
<-stop <-stop
s.Stop() s.Stop()
fmt.Println(fmt.Sprintf("\n%s HTTP server stopped", name)) fmt.Println(fmt.Sprintf("\n%s HTTP server stopped", name))
} }