Add ability to scrape and listen unix domain sockets

Signed-off-by: m.nabokikh <maksim.nabokikh@flant.com>

README.md

@@ -54,6 +54,12 @@ To start the exporter we use the [docker run](https://docs.docker.com/engine/ref
  ```
  where `<nginx-plus>` is the IP address/DNS name, through which NGINX Plus is available.
 
+* To export and scrape NGINX metrics with unix domain sockets, run:
+ ```
+ $ nginx-prometheus-exporter -nginx.scrape-uri unix:<nginx>:/stub_status -web.listen-address unix:/path/to/socket.sock
+ ```
+ where `<nginx>` is the path to unix domain socket, through which NGINX stub status is available.
+
 **Note**. The `nginx-prometheus-exporter` is not a daemon. To run the exporter as a system service (daemon), configure the init system of your Linux server (such as systemd or Upstart) accordingly. Alternatively, you can run the exporter in a Docker container.
 
 ## Usage
@@ -69,14 +75,14 @@ Usage of ./nginx-prometheus-exporter:
  -nginx.retry-interval duration
  An interval between retries to connect to the NGINX stub_status page/NGINX Plus API on start. The default value can be overwritten by NGINX_RETRY_INTERVAL environment variable. (default 5s)
  -nginx.scrape-uri string
- A URI for scraping NGINX or NGINX Plus metrics.
+ A URI or unix domain socket path for scraping NGINX or NGINX Plus metrics. 
  For NGINX, the stub_status page must be available through the URI. For NGINX Plus -- the API. The default value can be overwritten by SCRAPE_URI environment variable. (default "http://127.0.0.1:8080/stub_status")
  -nginx.ssl-verify
  Perform SSL certificate verification. The default value can be overwritten by SSL_VERIFY environment variable. (default true)
  -nginx.timeout duration
  A timeout for scraping metrics from NGINX or NGINX Plus. The default value can be overwritten by TIMEOUT environment variable. (default 5s)
  -web.listen-address string
- An address to listen on for web interface and telemetry. The default value can be overwritten by LISTEN_ADDRESS environment variable. (default ":9113")
+ An address or unix domain socket path to listen on for web interface and telemetry. The default value can be overwritten by LISTEN_ADDRESS environment variable. (default ":9113")
  -web.telemetry-path string
  A path under which to expose metrics. The default value can be overwritten by TELEMETRY_PATH environment variable. (default "/metrics")
 ```

exporter.go

@@ -1,14 +1,17 @@
 package main
 
 import (
+ "context"
  "crypto/tls"
  "flag"
  "fmt"
  "log"
+ "net"
  "net/http"
  "os"
  "os/signal"
  "strconv"
+ "strings"
  "syscall"
  "time"
 
@@ -110,6 +113,43 @@ func createClientWithRetries(getClient func() (interface{}, error), retries uint
  return nil, err
 }
 
+func parseUnixSocketAddress(address string) (string, string, error) {
+ addressParts := strings.Split(address, ":")
+ addressPartsLength := len(addressParts)
+
+ if addressPartsLength > 3 || addressPartsLength < 1 {
+ return "", "", fmt.Errorf("address for unix domain socket has wrong format")
+ }
+
+ unixSocketPath := addressParts[1]
+ requestPath := ""
+ if addressPartsLength == 3 {
+ requestPath = addressParts[2]
+ }
+ return unixSocketPath, requestPath, nil
+}
+
+func getListener(listenAddress string) (net.Listener, error) {
+ var listener net.Listener
+ var err error
+
+ if strings.HasPrefix(listenAddress, "unix:") {
+ path, _, pathError := parseUnixSocketAddress(listenAddress)
+ if pathError != nil {
+ return listener, fmt.Errorf("parsing unix domain socket listen address %s failed: %v", listenAddress, pathError)
+ }
+ listener, err = net.ListenUnix("unix", &net.UnixAddr{Name: path, Net: "unix"})
+ } else {
+ listener, err = net.Listen("tcp", listenAddress)
+ }
+
+ if err != nil {
+ return listener, err
+ }
+ log.Printf("Listening on %s", listenAddress)
+ return listener, nil
+}
+
 var (
  // Set during go build
  version string
@@ -128,7 +168,7 @@ var (
  // Command-line flags
  listenAddr = flag.String("web.listen-address",
  defaultListenAddress,
- "An address to listen on for web interface and telemetry. The default value can be overwritten by LISTEN_ADDRESS environment variable.")
+ "An address or unix domain socket path to listen on for web interface and telemetry. The default value can be overwritten by LISTEN_ADDRESS environment variable.")
  metricsPath = flag.String("web.telemetry-path",
  defaultMetricsPath,
  "A path under which to expose metrics. The default value can be overwritten by TELEMETRY_PATH environment variable.")
@@ -137,8 +177,8 @@ var (
  "Start the exporter for NGINX Plus. By default, the exporter is started for NGINX. The default value can be overwritten by NGINX_PLUS environment variable.")
  scrapeURI = flag.String("nginx.scrape-uri",
  defaultScrapeURI,
- `A URI for scraping NGINX or NGINX Plus metrics.
- For NGINX, the stub_status page must be available through the URI. For NGINX Plus -- the API. The default value can be overwritten by SCRAPE_URI environment variable.`)
+ `A URI or unix domain socket path for scraping NGINX or NGINX Plus metrics.
+For NGINX, the stub_status page must be available through the URI. For NGINX Plus -- the API. The default value can be overwritten by SCRAPE_URI environment variable.`)
  sslVerify = flag.Bool("nginx.ssl-verify",
  defaultSslVerify,
  "Perform SSL certificate verification. The default value can be overwritten by SSL_VERIFY environment variable.")
@@ -177,17 +217,37 @@ func main() {
 
  registry.MustRegister(buildInfoMetric)
 
+ transport := &http.Transport{
+ TLSClientConfig: &tls.Config{InsecureSkipVerify: !*sslVerify},
+ }
+ if strings.HasPrefix(*scrapeURI, "unix:") {
+ socketPath, requestPath, err := parseUnixSocketAddress(*scrapeURI)
+ if err != nil {
+ log.Fatalf("Parsing unix domain socket scrape address %s failed: %v", *scrapeURI, err)
+ }
+
+ transport.DialContext = func(_ context.Context, _, _ string) (net.Conn, error) {
+ return net.Dial("unix", socketPath)
+ }
+ newScrapeURI := "http://unix" + requestPath
+ scrapeURI = &newScrapeURI
+ }
+
  httpClient := &http.Client{
- Timeout: timeout.Duration,
- Transport: &http.Transport{
- TLSClientConfig: &tls.Config{InsecureSkipVerify: !*sslVerify},
- },
+ Timeout: timeout.Duration,
+ Transport: transport,
  }
 
+ srv := http.Server{}
+
  signalChan := make(chan os.Signal, 1)
- signal.Notify(signalChan, syscall.SIGTERM)
+ signal.Notify(signalChan, os.Interrupt, syscall.SIGTERM)
  go func() {
- log.Printf("SIGTERM received: %v. Exiting...", <-signalChan)
+ log.Printf("Signal received: %v. Exiting...", <-signalChan)
+ err := srv.Close()
+ if err != nil {
+ log.Fatalf("Error occurred while closing the server: %v", err)
+ }
  os.Exit(0)
  }()
 
@@ -221,6 +281,12 @@ func main() {
  log.Printf("Error while sending a response for the '/' path: %v", err)
  }
  })
+
+ listener, err := getListener(*listenAddr)
+ if err != nil {
+ log.Fatalf("Could not create listener: %v", err)
+ }
+
  log.Printf("NGINX Prometheus Exporter has successfully started")
- log.Fatal(http.ListenAndServe(*listenAddr, nil))
+ log.Fatal(srv.Serve(listener))
 }

exporter_test.go

@@ -121,3 +121,57 @@ func TestParsePositiveDuration(t *testing.T) {
  })
  }
 }
+
+func TestParseUnixSocketAddress(t *testing.T) {
+ tests := []struct {
+ name string
+ testInput string
+ wantSocketPath string
+ wantRequestPath string
+ wantErr bool
+ }{
+ {
+ "Normal unix socket address",
+ "unix:/path/to/socket",
+ "/path/to/socket",
+ "",
+ false,
+ },
+ {
+ "Normal unix socket address with location",
+ "unix:/path/to/socket:/with/location",
+ "/path/to/socket",
+ "/with/location",
+ false,
+ },
+ {
+ "Unix socket address with trailing ",
+ "unix:/trailing/path:",
+ "/trailing/path",
+ "",
+ false,
+ },
+ {
+ "Unix socket address with too many colons",
+ "unix:/too:/many:colons:",
+ "",
+ "",
+ true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ socketPath, requestPath, err := parseUnixSocketAddress(tt.testInput)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("parseUnixSocketAddress() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(socketPath, tt.wantSocketPath) {
+ t.Errorf("socket path: parseUnixSocketAddress() = %v, want %v", socketPath, tt.wantSocketPath)
+ }
+ if !reflect.DeepEqual(requestPath, tt.wantRequestPath) {
+ t.Errorf("request path: parseUnixSocketAddress() = %v, want %v", requestPath, tt.wantRequestPath)
+ }
+ })
+ }
+}