From 599da79da54712e0e5a371f8e2c8443ee9d1c57b Mon Sep 17 00:00:00 2001
From: schnoddelbotz <jan@hacker.ch>
Date: Sun, 26 May 2019 18:43:19 +0200
Subject: [PATCH] :tada: pop uds-proxy into github-existence

---
 .gitignore                                    |    6 +
 Makefile                                      |  119 ++
 README.md                                     |  177 +++
 cmd/test_server/main.go                       |   17 +
 cmd/uds-proxy/main.go                         |   37 +
 docker-compose.yml                            |   46 +
 go.mod                                        |   11 +
 go.sum                                        |   67 +
 monitoring/README.md                          |   39 +
 .../grafana/dashboards/GoProcesses.json       | 1000 +++++++++++++
 .../grafana/dashboards/Prometheus2.json       | 1307 +++++++++++++++++
 monitoring/grafana/dashboards/uds-proxy.json  |  304 ++++
 .../dashboards/uds-proxy-dev.yaml             |   13 +
 .../provisioning/datasources/prometheus.yaml  |   15 +
 monitoring/paint_graphs.sh                    |   70 +
 monitoring/prometheus.yml                     |   13 +
 proxy/metrics.go                              |   57 +
 proxy/proxy.go                                |  172 +++
 proxy/utility.go                              |   23 +
 proxy_test/functional_test.go                 |  150 ++
 proxy_test/unit_test.go                       |   41 +
 proxy_test_server/README.md                   |    7 +
 proxy_test_server/server.go                   |  103 ++
 proxy_test_server/test_server.Dockerfile      |   15 +
 uds-proxy.Dockerfile                          |   17 +
 25 files changed, 3826 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 Makefile
 create mode 100644 README.md
 create mode 100644 cmd/test_server/main.go
 create mode 100644 cmd/uds-proxy/main.go
 create mode 100644 docker-compose.yml
 create mode 100644 go.mod
 create mode 100644 go.sum
 create mode 100644 monitoring/README.md
 create mode 100644 monitoring/grafana/dashboards/GoProcesses.json
 create mode 100644 monitoring/grafana/dashboards/Prometheus2.json
 create mode 100644 monitoring/grafana/dashboards/uds-proxy.json
 create mode 100644 monitoring/grafana/provisioning/dashboards/uds-proxy-dev.yaml
 create mode 100644 monitoring/grafana/provisioning/datasources/prometheus.yaml
 create mode 100755 monitoring/paint_graphs.sh
 create mode 100644 monitoring/prometheus.yml
 create mode 100644 proxy/metrics.go
 create mode 100644 proxy/proxy.go
 create mode 100644 proxy/utility.go
 create mode 100644 proxy_test/functional_test.go
 create mode 100644 proxy_test/unit_test.go
 create mode 100644 proxy_test_server/README.md
 create mode 100644 proxy_test_server/server.go
 create mode 100644 proxy_test_server/test_server.Dockerfile
 create mode 100644 uds-proxy.Dockerfile

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..96155b8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+/uds-proxy
+/test_server
+coverage*
+.idea/
+uds-proxy.iml
+uds-proxy.pid
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..c4ac656
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,119 @@
+
+BINARY := uds-proxy
+
+VERSION := $(shell git describe --tags | cut -dv -f2)
+DOCKER_IMAGE := schnoddelbotz/uds-proxy
+LDFLAGS := -X github.com/schnoddelbotz/uds-proxy/proxy.AppVersion=$(VERSION) -w
+
+TEST_SOCKET   := $(PWD)/uds-proxy-test.socket
+TEST_PIDFILE  := uds-proxy.pid
+TEST_PROMETHEUS_PORT := 18080
+TEST_DOCKERIZED_SOCKET_DIR := $(PWD)/udsproxy_docker_test
+TEST_DOCKERIZED_SOCKET := $(TEST_DOCKERIZED_SOCKET_DIR)/uds-proxy-docker.sock
+
+IS_MAC := $(shell test "Darwin" = "`uname -s`" && echo 1)
+USE_DOCKER := $(shell test $(IS_MAC) || echo _docker)
+
+
+build: $(BINARY)
+
+$(BINARY): cmd/uds-proxy/main.go proxy/*.go
+	env go build -ldflags='-w -s $(LDFLAGS)' ./cmd/uds-proxy
+
+test_server: cmd/test_server/main.go proxy_test_server/server.go
+	go build ./cmd/test_server
+
+zip: $(BINARY)
+	zip $(BINARY)_$(GOOS)-$(GOARCH)_$(VERSION).zip $(BINARY)
+
+release: test realclean
+	env GOOS=linux  GOARCH=amd64 make clean zip
+	env GOOS=darwin GOARCH=amd64 make clean zip
+
+
+run_proxy: $(BINARY)
+	-./$(BINARY) -socket $(TEST_SOCKET) -pid-file $(TEST_PIDFILE) \
+		-prometheus-port :$(TEST_PROMETHEUS_PORT) -no-log-timestamps $(EXTRA_ARGS)
+
+run_proxy_docker:
+	@echo "run_proxy_docker: Wait for docker-composed uds-proxy to come up; or use 'make docker_run'"
+	# preparing mount directory for dockerized uds-proxy socket
+	mkdir -p $(TEST_DOCKERIZED_SOCKET_DIR)
+	chmod 777 $(TEST_DOCKERIZED_SOCKET_DIR)
+
+run_test_server: test_server
+	./test_server
+
+run_test_server_docker:
+	echo "INFO: run_test_server_docker is a noop, it's always started via docker-compose"
+
+
+test: test_go_unit test_go_functional
+
+test_go_unit:
+	go test -ldflags='-w -s $(LDFLAGS)' -tags=unit ./proxy_test
+
+test_go_functional:
+	go test -tags=functional ./proxy_test
+
+test_integration:
+	# test_integration: same as monitoring test, but without Prometheus and Grafana
+	make -j4 compose_up_no_metrics run_proxy$(USE_DOCKER) run_test_server$(USE_DOCKER) run_some_requests$(USE_DOCKER)
+
+
+coverage: clean
+	go test -coverprofile=coverage.out -coverpkg="github.com/schnoddelbotz/uds-proxy/proxy" \
+		-tags="functional unit" -ldflags='-w -s $(LDFLAGS)' ./proxy_test
+	go tool cover -html=coverage.out
+
+monitoring_test:
+	# visit Grafana on http://localhost:3000/ ... (re-)run_some_requests ... and ctrl-c to quit
+	make -j2 compose_build compose_pull
+	make -j4 compose_up run_proxy$(USE_DOCKER) run_test_server$(USE_DOCKER) run_some_requests$(USE_DOCKER)
+
+run_some_requests:
+	sh monitoring/paint_graphs.sh $(TEST_SOCKET) http://localhost:25777
+
+run_some_requests_docker:
+	sh monitoring/paint_graphs.sh $(TEST_DOCKERIZED_SOCKET) http://testserver:44555 use-sudo
+
+
+docker_image: clean
+	docker build -f uds-proxy.Dockerfile -t $(DOCKER_IMAGE):$(VERSION) -t $(DOCKER_IMAGE):latest .
+
+docker_image_push:
+	docker push $(DOCKER_IMAGE)
+
+docker_run:
+	@if [ $(IS_MAC) ]; then echo "Mounting UDS does not work on Mac. Use 'make run_proxy' instead"; exit 1; fi
+	docker run --rm -it -p28080:28080 -v$(TEST_DOCKERIZED_SOCKET_DIR):/tmp $(DOCKER_IMAGE) $(EXTRA_ARGS)
+
+
+compose_build:
+	docker-compose build
+
+compose_pull:
+	docker-compose pull
+
+compose_up:
+	docker-compose up --force-recreate
+
+compose_up_no_metrics:
+	docker-compose up --force-recreate udsproxy testserver
+
+
+grafana_dump_udsproxy_dashboard:
+	DASH_COPY_1_UID=$(shell curl -s 'localhost:3000/api/search' | jq -r '.[] | select(.id==5) | .uid'); \
+	curl -s localhost:3000/api/dashboards/uid/$$DASH_COPY_1_UID | \
+		jq '.dashboard|.id=null|.title="uds-proxy stats"|.uid="ups"' \
+		> monitoring/grafana/dashboards/uds-proxy.json
+	git diff monitoring/grafana/dashboards/uds-proxy.json
+
+
+clean:
+	rm -f $(BINARY) $(TEST_SOCKET) $(TEST_PIDFILE) test_server coverage*
+
+realclean: clean
+	-docker-compose down --volumes
+	-docker-compose rm -f
+	rm -rf $(BINARY)*.zip $(TEST_DOCKERIZED_SOCKET_DIR)
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..5fc6ac9
--- /dev/null
+++ b/README.md
@@ -0,0 +1,177 @@
+# uds-proxy
+uds-proxy provides a UNIX domain socket and forwards traffic to HTTP(S) remotes
+through a customizable connection pool (i.e. using persistent connections).
+
+## what for? why? how?
+Interacting with microservices often involves communication overhead: Every contact
+with another service may involve DNS lookups and establishment of a TCP connection
+plus, most likely, a HTTPS handshake.
+
+This overhead can be costly and especially hard to circumvent for legacy applications -- thus uds-proxy.
+
+uds-proxy creates a UNIX domain socket and forwards communication to one or more
+remote web servers. In a way, uds-proxy aims a bit at reducing application/API complexity by
+providing a generic and simple solution for connection pooling.
+
+uds-proxy is implemented in Go, so it runs as native application on any
+OS supporting Go and UNIX domain sockets (i.e. not on Windows). Critical
+performance metrics of uds-proxy (request latencies, response codes...)
+and Go process statistics are exposed through Prometheus client library.
+
+## building / installing uds-proxy
+
+Building requires a local Go 1.11+ installation:
+
+```bash
+go get -v github.com/schnoddelbotz/uds-proxy/cmd/uds-proxy
+```
+
+... or just grab a [uds-proxy binary release](https://github.com/schnoddelbotz/uds-proxy/releases).
+
+See [usage-example-for-an-https-endpoint](#usage-example-for-an-https-endpoint) for Docker usage.
+
+To start uds-proxy at system boot, create e.g. a systemd unit.
+Don't try to run uds-proxy as root. It won't start.
+
+## usage
+
+```
+Usage of ./uds-proxy:
+  -client-timeout int
+      http client connection timeout [ms] for proxy requests (default 5000)
+  -idle-timeout int
+      connection timeout [ms] for idle backend connections (default 90000)
+  -max-conns-per-host int
+      maximum number of connections per backend host (default 20)
+  -max-idle-conns int
+      maximum number of idle HTTP(S) connections (default 100)
+  -max-idle-conns-per-host int
+      maximum number of idle conns per backend (default 25)
+  -no-log-timestamps
+      disable timestamps in log messages
+  -pid-file string
+      pid file to use, none if empty
+  -prometheus-port string
+      Prometheus monitoring port, e.g. :18080
+  -remote-https
+      remote uses https://
+  -socket string
+      path of socket to create
+  -socket-read-timeout int
+      read timeout [ms] for -socket (default 5000)
+  -socket-write-timeout int
+      write timeout [ms] for -socket (default 5000)
+  -version
+      print uds-proxy version
+```
+
+## monitoring / testing / development
+
+Clone this repository and check the [Makefile](Makefile) targets.
+
+Most relevant `make` targets:
+
+- `make monitoring_test` spins up Prometheus, grafana and uds-proxy using Docker and
+  starts another uds-proxy instance locally (outside Docker, on Mac only). The uds-proxy instances will be
+  scraped by dockerized Prometheus and Grafana will provide dashboards.
+  See [monitoring/README.md](monitoring/README.md) for details.
+- `make run_proxy` starts a local uds-proxy instance for testing purposes.
+  `TEST_SOCKET` environment variable controls socket location, defaults
+  to `uds-proxy-test.socket`.
+- `make test` runs unit and functional tests from [proxy_test](proxy_test) directory.
+- `make coverage` generates code test coverage statistics.
+- `make test_integration` starts a local uds-proxy and runs some proxied-vs-non-proxied perf tests.
+- `make realclean` removes leftovers from tests or builds.
+
+### usage example for an HTTPS endpoint
+Start the proxy:
+
+```bash
+uds-proxy -socket /tmp/proxied-svc.sock -prometheus-port :28080 -remote-https
+```
+
+Docker users:
+
+```bash
+mkdir -p /tmp/mysock_dir
+docker run --rm -it -p28080:28080 -v/tmp/mysock_dir:/tmp schnoddelbotz/uds-proxy
+```
+
+For both cases, metrics should be available at http://localhost:28080/metrics while uds-proxy is running.
+
+#### using bash / curl
+```bash
+# without uds-proxy, you would...
+time curl -I https://www.google.com/
+
+# with uds-proxy, always ...
+# a) talk through socket and
+# b) use http:// and let `-remote-https` ensure https is used to connect to remote hosts
+time curl -I --unix-socket /tmp/proxied-svc.sock http://www.google.com/
+# ... or using socket provided by dockerized uds-proxy:
+time curl -I --unix-socket /tmp/mysock_dir/uds-proxy-docker.sock http://www.google.com/
+```
+
+#### using php / curl
+```php
+<?php
+// without uds-proxy
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, "https://www.google.com/");
+curl_exec($ch);
+
+// with uds-proxy
+$ch = curl_init();
+curl_setopt($ch, CURLOPT_URL, "http://www.google.com/");
+curl_setopt($ch, CURLOPT_UNIX_SOCKET_PATH, "/tmp/proxied-svc.sock");
+curl_exec($ch);
+```
+
+### further socket testing
+
+Mac's (i.e. BSD's) netcat allows to talk to unix domain sockets.
+It can be used to e.g. ensure correct behaviour of uds-proxy's
+`-socket-(read|write)-timeout` options. Simply use `nc -U /path/to/uds-proxy.sock`.
+
+## todo ...
+
+- fix heatmap
+- fix/drop sudo nobody for dockerized tests
+- fixme: add option [-dont-follow-redirects](https://stackoverflow.com/questions/23297520/how-can-i-make-the-go-http-client-not-follow-redirects-automatically)
+- add a circuit breaker and or exponential backoff?
+- cleanup: wrap handleProxyRequest into logging handler
+- travis-ci + github release push
+- level-based stdout/err logging https://awesome-go.com/#logging
+- example systemd unit
+- log request sizes?
+- use/fix 'make test' in Dockerfile
+- sock umask / cli opt
+- support magic uds request headers...?
+  - X-udsproxy-timeout: 250ms
+  - X-udsproxy-debug: true
+
+## links
+
+- https://godoc.org/gotest.tools/assert
+- https://golang.org/pkg/net/#hdr-Name_Resolution
+- https://stackoverflow.com/questions/17948827/reusing-http-connections-in-golang
+- https://medium.com/@povilasve/go-advanced-tips-tricks-a872503ac859
+- https://github.com/bouk/monkey/blob/master/monkey_test.go
+- https://github.com/prometheus/client_golang/blob/master/prometheus/examples_test.go
+- https://github.com/prometheus/client_golang/blob/master/prometheus/promhttp/instrument_server.go
+
+## alternatives
+
+- for Python and Redis, use a [redis.py connection pool](https://github.com/andymccurdy/redis-py#connection-pools)
+- for Python and HTTP, requests library will just do it
+- for Redis and PHP, [phpredis](https://github.com/phpredis/phpredis) supports experimental persistent connections
+- a potentially more sophisticated solution can be found in
+  [this TCP vs UDS speed comparison stackoverflow thread](https://stackoverflow.com/questions/14973942/performance-tcp-loopback-connection-vs-unix-domain-socket):
+  [Speedus](http://speedus.torusware.com/) intercepts relevant system calls, which avoids
+  need for any code changes. However, if I understood correctly, Speedus only helps if
+  services actually sit on the same host system.
+
+
+## license
+
+MIT
diff --git a/cmd/test_server/main.go b/cmd/test_server/main.go
new file mode 100644
index 0000000..5ad327d
--- /dev/null
+++ b/cmd/test_server/main.go
@@ -0,0 +1,17 @@
+package main
+
+import (
+	"flag"
+
+	"github.com/schnoddelbotz/uds-proxy/proxy_test_server"
+)
+
+func main() {
+	var port string
+	flag.StringVar(&port, "port", ":25777", "fake webserver tcp port")
+	// could add flag to exit after N requests?
+	// could add flag to exit after N seconds?
+	flag.Parse()
+
+	proxy_test_server.RunUpstreamFakeServer(port, false)
+}
diff --git a/cmd/uds-proxy/main.go b/cmd/uds-proxy/main.go
new file mode 100644
index 0000000..75b27f6
--- /dev/null
+++ b/cmd/uds-proxy/main.go
@@ -0,0 +1,37 @@
+package main
+
+import (
+	"flag"
+	"os"
+
+	"github.com/schnoddelbotz/uds-proxy/proxy"
+)
+
+func main() {
+	var args proxy.CliArgs
+
+	if os.Getuid() == 0 {
+		println("uds-proxy is refusing to run as root user")
+		os.Exit(1)
+	}
+
+	flag.BoolVar(&args.NoLogTimeStamps, "no-log-timestamps", false, "disable timestamps in log messages")
+	flag.BoolVar(&args.PrintVersion, "version", false, "print uds-proxy version")
+	flag.BoolVar(&args.RemoteHTTPS, "remote-https", false, "remote uses https://")
+
+	flag.IntVar(&args.MaxConnsPerHost, "max-conns-per-host", 20, "maximum number of connections per backend host")
+	flag.IntVar(&args.MaxIdleConns, "max-idle-conns", 100, "maximum number of idle HTTP(S) connections")
+	flag.IntVar(&args.MaxIdleConnsPerHost, "max-idle-conns-per-host", 25, "maximum number of idle conns per backend")
+	flag.IntVar(&args.ClientTimeout, "client-timeout", 5000, "http client connection timeout [ms] for proxy requests")
+	flag.IntVar(&args.IdleConnTimeout, "idle-timeout", 90000, "connection timeout [ms] for idle backend connections")
+	flag.IntVar(&args.SocketReadTimeout, "socket-read-timeout", 5000, "read timeout [ms] for -socket")
+	flag.IntVar(&args.SocketWriteTimeout, "socket-write-timeout", 5000, "write timeout [ms] for -socket")
+
+	flag.StringVar(&args.PidFile, "pid-file", "", "pid file to use, none if empty")
+	flag.StringVar(&args.SocketPath, "socket", os.Getenv("UDS_PROXY_SOCKET"), "path of socket to create")
+	flag.StringVar(&args.PrometheusPort, "prometheus-port", "", "Prometheus monitoring port, e.g. :18080")
+
+	flag.Parse()
+
+	proxy.NewProxyInstance(args).Run()
+}
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..40ab762
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,46 @@
+version: '3.0'
+
+services:
+
+  grafana:
+    image: grafana/grafana
+    environment:
+      - GF_AUTH_ANONYMOUS_ENABLED=true
+      - GF_AUTH_ANONYMOUS_ORG_ROLE=Admin
+    ports:
+      - 3000:3000
+    logging:
+      driver: none
+    depends_on:
+      - prometheus
+    volumes:
+      - ./monitoring/grafana/provisioning:/etc/grafana/provisioning
+      - ./monitoring/grafana/dashboards:/var/lib/grafana/dashboards
+
+  prometheus:
+    image: prom/prometheus
+    logging:
+      driver: none
+    ports:
+      - 9090:9090
+    volumes:
+      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
+
+  udsproxy:
+    image: schnoddelbotz/uds-proxy
+    build:
+      context: .
+      dockerfile: uds-proxy.Dockerfile
+    ports:
+      - 28080:28080
+    volumes:
+      - ./udsproxy_docker_test:/tmp
+
+  testserver:
+    environment:
+      - TEST_SERVER_PORT=44555
+    build:
+      context: .
+      dockerfile: proxy_test_server/test_server.Dockerfile
+    ports:
+      - 25778:44555
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..ff6a57b
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,11 @@
+module github.com/schnoddelbotz/uds-proxy
+
+go 1.12
+
+require (
+	github.com/google/go-cmp v0.3.0 // indirect
+	github.com/pkg/errors v0.8.1 // indirect
+	github.com/prometheus/client_golang v0.9.3
+	github.com/stretchr/testify v1.3.0
+	gotest.tools v2.2.0+incompatible
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..676d66a
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,67 @@
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/go-cmp v0.3.0 h1:crn/baboCvb5fXaQ0IJ1SGTsTVrWpDsCWC8EGETZijY=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3 h1:9iH4JKXLzFbOAdtqv/a+j8aewx2Y8lAjAydhbaScPF8=
+github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.4.0 h1:7etb9YClo3a6HjLzfl6rIQaU+FDfi0VSX39io3aQ+DM=
+github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084 h1:sofwID9zm4tzrgykg80hfFph1mryUeLRsUfoocVVmRY=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
+gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
diff --git a/monitoring/README.md b/monitoring/README.md
new file mode 100644
index 0000000..d627805
--- /dev/null
+++ b/monitoring/README.md
@@ -0,0 +1,39 @@
+# monitoring uds-proxy
+
+Exposure of performance metrics can be enabled by using uds-proxy's 
+`-prometheus-port` command line argument. For example, using `-prometheus-port :12345` 
+will make metrics available at `http://localhost:12345/metrics`.
+
+This directory contains Grafana provisioning configuration and prometheus
+configuration used by [docker-compose.yml](../docker-compose.yml) to
+spin up an example uds-proxy dashboard, fed with live data.
+
+From uds-proxy source root directory, run
+
+```bash
+make monitoring_test
+```
+
+to bring up uds-proxy, Prometheus and Grafana for experiments. This will...
+
+- on Mac: build and run uds-proxy locally on your host (requires Go)
+- on Linux: build and run uds-proxy using Docker 
+- spin up Prometheus, configured to collect metrics from uds-proxy
+- spin up Grafana, configured with prometheus as datasource and uds-proxy dashboard
+- timeit: run 50 test requests directly and 50 via uds-proxy
+
+Then...
+
+- visit http://localhost:3000 and select one of the three dashboards available:
+  - [uds-proxy stats](http://localhost:3000/d/ups/uds-proxy-stats?orgId=1)
+  - [go process stats](http://localhost:3000/d/go/go-stats?orgId=1)
+  - [prometheus stats](http://localhost:3000/d/prom/prometheus-stats?orgId=1)
+- use `uds-proxy-test.socket` for further tests, eg. use `make run_some_requests`
+
+Shut the test environment down and **lose all collected data** by hitting ctrl-c.
+
+Why does `make monitoring_test` spin up two uds-proxy instances on Mac -- a local one and a dockerized one? 
+[Because](https://github.com/docker/for-mac/issues/483) containers on Docker for 
+Mac will never be able to share a socket with the host. So, for testing purposes,
+a 2nd instance is started locally to enable test runs, while the dockerized one
+is sitting idle.
\ No newline at end of file
diff --git a/monitoring/grafana/dashboards/GoProcesses.json b/monitoring/grafana/dashboards/GoProcesses.json
new file mode 100644
index 0000000..114a9a6
--- /dev/null
+++ b/monitoring/grafana/dashboards/GoProcesses.json
@@ -0,0 +1,1000 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "description": "Process status published by Go Prometheus client library, e.g. memory used, fds open, GC details",
+  "editable": true,
+  "gnetId": 6671,
+  "graphTooltip": 0,
+  "id": null,
+  "iteration": 1558479828752,
+  "links": [],
+  "panels": [
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "rightSide": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "resident",
+          "yaxis": 2
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "process_resident_memory_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - resident",
+          "metric": "process_resident_memory_bytes",
+          "refId": "A",
+          "step": 4
+        },
+        {
+          "expr": "process_virtual_memory_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - virtual",
+          "metric": "process_virtual_memory_bytes",
+          "refId": "B",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "process memory",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 4,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "resident",
+          "yaxis": 1
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(process_resident_memory_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - resident",
+          "metric": "process_resident_memory_bytes",
+          "refId": "A",
+          "step": 4
+        },
+        {
+          "expr": "deriv(process_virtual_memory_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - virtual",
+          "metric": "process_virtual_memory_bytes",
+          "refId": "B",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "process memory deriv",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 0,
+        "y": 8
+      },
+      "id": 2,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "alloc rate",
+          "yaxis": 2
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "go_memstats_alloc_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - bytes allocated",
+          "metric": "go_memstats_alloc_bytes",
+          "refId": "A",
+          "step": 4
+        },
+        {
+          "expr": "rate(go_memstats_alloc_bytes_total{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[30s])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - alloc rate",
+          "metric": "go_memstats_alloc_bytes_total",
+          "refId": "B",
+          "step": 4
+        },
+        {
+          "expr": "go_memstats_stack_inuse_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - stack inuse",
+          "metric": "go_memstats_stack_inuse_bytes",
+          "refId": "C",
+          "step": 4
+        },
+        {
+          "expr": "go_memstats_heap_inuse_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "hide": false,
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - heap inuse",
+          "metric": "go_memstats_heap_inuse_bytes",
+          "refId": "D",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "go memstats",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "Bps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 12,
+        "y": 8
+      },
+      "id": 5,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "alloc rate",
+          "yaxis": 2
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "deriv(go_memstats_alloc_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - bytes allocated",
+          "metric": "go_memstats_alloc_bytes",
+          "refId": "A",
+          "step": 4
+        },
+        {
+          "expr": "rate(go_memstats_alloc_bytes_total{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - alloc rate",
+          "metric": "go_memstats_alloc_bytes_total",
+          "refId": "B",
+          "step": 4
+        },
+        {
+          "expr": "deriv(go_memstats_stack_inuse_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - stack inuse",
+          "metric": "go_memstats_stack_inuse_bytes",
+          "refId": "C",
+          "step": 4
+        },
+        {
+          "expr": "deriv(go_memstats_heap_inuse_bytes{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "hide": false,
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}} - heap inuse",
+          "metric": "go_memstats_heap_inuse_bytes",
+          "refId": "D",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "go memstats deriv",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "bytes",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "Bps",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 0,
+        "y": 15
+      },
+      "id": 3,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "process_open_fds{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}}",
+          "metric": "process_open_fds",
+          "refId": "A",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "open fds",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 12,
+        "y": 15
+      },
+      "id": 6,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "deriv(process_open_fds{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}[$interval])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}}",
+          "metric": "process_open_fds",
+          "refId": "A",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "open fds deriv",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 0,
+        "y": 22
+      },
+      "id": 7,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "go_goroutines{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}}",
+          "metric": "go_goroutines",
+          "refId": "A",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Goroutines",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 1,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 12,
+        "y": 22
+      },
+      "id": 8,
+      "isNew": true,
+      "legend": {
+        "alignAsTable": true,
+        "avg": true,
+        "current": true,
+        "max": true,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": true
+      },
+      "lines": true,
+      "linewidth": 2,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "go_gc_duration_seconds{namespace=~\"^($namespace)$\",pod=~\"^($pod)$\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{pod}}: {{quantile}}",
+          "metric": "go_gc_duration_seconds",
+          "refId": "A",
+          "step": 4
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "GC duration quantiles",
+      "tooltip": {
+        "msResolution": false,
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    }
+  ],
+  "refresh": "5s",
+  "schemaVersion": 18,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": [
+      {
+        "allValue": ".*",
+        "current": {
+          "text": "All",
+          "value": "$__all"
+        },
+        "datasource": "Prometheus",
+        "definition": "",
+        "hide": 0,
+        "includeAll": true,
+        "label": null,
+        "multi": true,
+        "name": "namespace",
+        "options": [],
+        "query": "label_values(go_memstats_alloc_bytes, namespace)",
+        "refresh": 2,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      },
+      {
+        "allValue": ".*",
+        "current": {
+          "text": "All",
+          "value": "$__all"
+        },
+        "datasource": "Prometheus",
+        "definition": "",
+        "hide": 0,
+        "includeAll": true,
+        "label": null,
+        "multi": true,
+        "name": "pod",
+        "options": [],
+        "query": "label_values(process_resident_memory_bytes, pod)",
+        "refresh": 2,
+        "regex": "",
+        "skipUrlSync": false,
+        "sort": 0,
+        "tagValuesQuery": "",
+        "tags": [],
+        "tagsQuery": "",
+        "type": "query",
+        "useTags": false
+      },
+      {
+        "auto": false,
+        "auto_count": 30,
+        "auto_min": "10s",
+        "current": {
+          "text": "5m",
+          "value": "5m"
+        },
+        "datasource": null,
+        "hide": 0,
+        "includeAll": false,
+        "label": "",
+        "multi": false,
+        "name": "interval",
+        "options": [
+          {
+            "selected": false,
+            "text": "1m",
+            "value": "1m"
+          },
+          {
+            "selected": true,
+            "text": "5m",
+            "value": "5m"
+          },
+          {
+            "selected": false,
+            "text": "10m",
+            "value": "10m"
+          },
+          {
+            "selected": false,
+            "text": "30m",
+            "value": "30m"
+          },
+          {
+            "selected": false,
+            "text": "1h",
+            "value": "1h"
+          }
+        ],
+        "query": "1m,5m,10m,30m,1h",
+        "refresh": 2,
+        "skipUrlSync": false,
+        "type": "interval"
+      }
+    ]
+  },
+  "time": {
+    "from": "now-30m",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ],
+    "time_options": [
+      "5m",
+      "15m",
+      "1h",
+      "6h",
+      "12h",
+      "24h",
+      "2d",
+      "7d",
+      "30d"
+    ]
+  },
+  "timezone": "browser",
+  "title": "Go stats",
+  "uid": "go",
+  "version": 1
+}
\ No newline at end of file
diff --git a/monitoring/grafana/dashboards/Prometheus2.json b/monitoring/grafana/dashboards/Prometheus2.json
new file mode 100644
index 0000000..4f9911d
--- /dev/null
+++ b/monitoring/grafana/dashboards/Prometheus2.json
@@ -0,0 +1,1307 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 1,
+  "id": null,
+  "links": [
+    {
+      "icon": "info",
+      "tags": [],
+      "targetBlank": true,
+      "title": "Grafana Docs",
+      "tooltip": "",
+      "type": "link",
+      "url": "http://docs.grafana.org/"
+    },
+    {
+      "icon": "info",
+      "tags": [],
+      "targetBlank": true,
+      "title": "Prometheus Docs",
+      "type": "link",
+      "url": "http://prometheus.io/docs/introduction/overview/"
+    }
+  ],
+  "panels": [
+    {
+      "aliasColors": {
+        "prometheus": "#C15C17",
+        "{instance=\"localhost:9090\",job=\"prometheus\"}": "#CCA300"
+      },
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 0,
+      "grid": {},
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 0,
+        "y": 0
+      },
+      "id": 3,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(irate(prometheus_tsdb_head_samples_appended_total{job=\"prometheus\"}[5m]))",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "samples",
+          "metric": "",
+          "refId": "A",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Samples Appended",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 0,
+      "grid": {},
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 6,
+        "y": 0
+      },
+      "id": 14,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "topk(5, max(scrape_duration_seconds) by (job))",
+          "format": "time_series",
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "{{job}}",
+          "metric": "",
+          "refId": "A",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Scrape Duration",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "s",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "description": "",
+      "fill": 0,
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 12,
+        "y": 0
+      },
+      "id": 16,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(process_resident_memory_bytes{job=\"prometheus\"})",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "p8s process resident memory",
+          "refId": "D",
+          "step": 20
+        },
+        {
+          "expr": "process_virtual_memory_bytes{job=\"prometheus\"}",
+          "format": "time_series",
+          "hide": false,
+          "intervalFactor": 2,
+          "legendFormat": "virtual memory",
+          "refId": "C",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Memory Profile",
+      "tooltip": {
+        "shared": true,
+        "sort": 2,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "bytes",
+          "label": "",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "cacheTimeout": null,
+      "colorBackground": false,
+      "colorValue": true,
+      "colors": [
+        "rgba(50, 172, 45, 0.97)",
+        "rgba(237, 129, 40, 0.89)",
+        "rgba(245, 54, 54, 0.9)"
+      ],
+      "datasource": "Prometheus",
+      "format": "none",
+      "gauge": {
+        "maxValue": 100,
+        "minValue": 0,
+        "show": false,
+        "thresholdLabels": false,
+        "thresholdMarkers": true
+      },
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 18,
+        "y": 0
+      },
+      "id": 37,
+      "interval": null,
+      "links": [],
+      "mappingType": 1,
+      "mappingTypes": [
+        {
+          "name": "value to text",
+          "value": 1
+        },
+        {
+          "name": "range to text",
+          "value": 2
+        }
+      ],
+      "maxDataPoints": 100,
+      "nullPointMode": "connected",
+      "nullText": null,
+      "postfix": "",
+      "postfixFontSize": "50%",
+      "prefix": "",
+      "prefixFontSize": "50%",
+      "rangeMaps": [
+        {
+          "from": "null",
+          "text": "N/A",
+          "to": "null"
+        }
+      ],
+      "sparkline": {
+        "fillColor": "rgba(31, 118, 189, 0.18)",
+        "full": false,
+        "lineColor": "rgb(31, 120, 193)",
+        "show": false
+      },
+      "tableColumn": "",
+      "targets": [
+        {
+          "expr": "prometheus_tsdb_wal_corruptions_total{job=\"prometheus\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "",
+          "refId": "A",
+          "step": 60
+        }
+      ],
+      "thresholds": "0.1,1",
+      "title": "WAL Corruptions",
+      "type": "singlestat",
+      "valueFontSize": "200%",
+      "valueMaps": [
+        {
+          "op": "=",
+          "text": "None",
+          "value": "0"
+        }
+      ],
+      "valueName": "max"
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "fill": 0,
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 0,
+        "y": 5
+      },
+      "id": 29,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "sum(prometheus_tsdb_head_active_appenders{job=\"prometheus\"})",
+          "format": "time_series",
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "active_appenders",
+          "metric": "",
+          "refId": "A",
+          "step": 20
+        },
+        {
+          "expr": "sum(process_open_fds{job=\"prometheus\"})",
+          "format": "time_series",
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "open_fds",
+          "refId": "B",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Active Appenders",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {
+        "prometheus": "#F9BA8F",
+        "{instance=\"localhost:9090\",interval=\"5s\",job=\"prometheus\"}": "#F9BA8F"
+      },
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "editable": true,
+      "error": false,
+      "fill": 0,
+      "grid": {},
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 6,
+        "y": 5
+      },
+      "id": 2,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "prometheus_tsdb_blocks_loaded{job=\"prometheus\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "blocks",
+          "refId": "A",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Blocks Loaded",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "decimals": null,
+      "description": "",
+      "fill": 0,
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 12,
+        "y": 5
+      },
+      "id": 33,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "prometheus_tsdb_head_chunks{job=\"prometheus\"}",
+          "format": "time_series",
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "chunks",
+          "refId": "A",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Head Chunks",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "bytes",
+          "label": "",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": false
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "fill": 1,
+      "gridPos": {
+        "h": 5,
+        "w": 6,
+        "x": 18,
+        "y": 5
+      },
+      "id": 36,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "duration-p99",
+          "yaxis": 2
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "prometheus_tsdb_head_gc_duration_seconds{job=\"prometheus\",quantile=\"0.99\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "duration-p99",
+          "refId": "A",
+          "step": 20
+        },
+        {
+          "expr": "irate(prometheus_tsdb_head_gc_duration_seconds_count{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "collections",
+          "refId": "B",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Head Block GC Activity",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "s",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "decimals": null,
+      "description": "",
+      "fill": 0,
+      "gridPos": {
+        "h": 5,
+        "w": 8,
+        "x": 0,
+        "y": 10
+      },
+      "id": 20,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [
+        {
+          "alias": "duration-p99",
+          "yaxis": 2
+        }
+      ],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "histogram_quantile(0.99, sum(rate(prometheus_tsdb_compaction_duration_bucket{job=\"prometheus\"}[5m])) by (le))",
+          "format": "time_series",
+          "hide": false,
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "duration-{{p99}}",
+          "refId": "A",
+          "step": 20
+        },
+        {
+          "expr": "irate(prometheus_tsdb_compactions_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "compactions",
+          "refId": "B",
+          "step": 20
+        },
+        {
+          "expr": "irate(prometheus_tsdb_compactions_failed_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "failed",
+          "refId": "C",
+          "step": 20
+        },
+        {
+          "expr": "irate(prometheus_tsdb_compactions_triggered_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "triggered",
+          "refId": "D",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Compaction Activity",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "s",
+          "label": "",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "fill": 1,
+      "gridPos": {
+        "h": 5,
+        "w": 8,
+        "x": 8,
+        "y": 10
+      },
+      "id": 32,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(prometheus_tsdb_reloads_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "reloads",
+          "refId": "A",
+          "step": 20
+        },
+        {
+          "expr": "rate(prometheus_tsdb_reloads_failures_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "hide": false,
+          "intervalFactor": 2,
+          "legendFormat": "failures",
+          "refId": "B",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Reload Count",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "fill": 0,
+      "gridPos": {
+        "h": 5,
+        "w": 8,
+        "x": 16,
+        "y": 10
+      },
+      "id": 38,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "prometheus_engine_query_duration_seconds{job=\"prometheus\", quantile=\"0.99\"}",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "{{slice}}_p99",
+          "refId": "A",
+          "step": 20
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Query Durations",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "decimals": null,
+      "editable": true,
+      "error": false,
+      "fill": 0,
+      "grid": {},
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 0,
+        "y": 15
+      },
+      "id": 35,
+      "legend": {
+        "alignAsTable": false,
+        "avg": false,
+        "current": false,
+        "hideEmpty": true,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "connected",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "max(prometheus_rule_group_duration_seconds{job=\"prometheus\"}) by (quantile)",
+          "format": "time_series",
+          "interval": "",
+          "intervalFactor": 2,
+          "legendFormat": "{{quantile}}",
+          "refId": "A",
+          "step": 10
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Rule Group Eval Duration",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "cumulative"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "s",
+          "label": "",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "Prometheus",
+      "fill": 1,
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 12,
+        "y": 15
+      },
+      "id": 39,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "percentage": false,
+      "pointradius": 5,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": true,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "rate(prometheus_rule_group_iterations_missed_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "missed",
+          "refId": "B",
+          "step": 10
+        },
+        {
+          "expr": "rate(prometheus_rule_group_iterations_total{job=\"prometheus\"}[5m])",
+          "format": "time_series",
+          "intervalFactor": 2,
+          "legendFormat": "iterations",
+          "refId": "A",
+          "step": 10
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Rule Group Eval Activity",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    }
+  ],
+  "refresh": "5s",
+  "revision": "1.0",
+  "schemaVersion": 18,
+  "style": "dark",
+  "tags": [
+    "prometheus"
+  ],
+  "templating": {
+    "list": []
+  },
+  "time": {
+    "from": "now-30m",
+    "to": "now"
+  },
+  "timepicker": {
+    "now": true,
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ],
+    "time_options": [
+      "5m",
+      "15m",
+      "1h",
+      "6h",
+      "12h",
+      "24h",
+      "2d",
+      "7d",
+      "30d"
+    ]
+  },
+  "timezone": "browser",
+  "title": "prometheus stats",
+  "uid": "prom",
+  "version": 1
+}
\ No newline at end of file
diff --git a/monitoring/grafana/dashboards/uds-proxy.json b/monitoring/grafana/dashboards/uds-proxy.json
new file mode 100644
index 0000000..a56d177
--- /dev/null
+++ b/monitoring/grafana/dashboards/uds-proxy.json
@@ -0,0 +1,304 @@
+{
+  "annotations": {
+    "list": [
+      {
+        "builtIn": 1,
+        "datasource": "-- Grafana --",
+        "enable": true,
+        "hide": true,
+        "iconColor": "rgba(0, 211, 255, 1)",
+        "name": "Annotations & Alerts",
+        "type": "dashboard"
+      }
+    ]
+  },
+  "editable": true,
+  "gnetId": null,
+  "graphTooltip": 0,
+  "id": null,
+  "links": [],
+  "panels": [
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "fill": 1,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 0
+      },
+      "id": 6,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "options": {},
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "udsproxy_http_requests_total",
+          "format": "time_series",
+          "interval": "",
+          "intervalFactor": 1,
+          "legendFormat": "{{code}} {{method}}",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "udsproxy_http_requests_total",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "format": "short",
+          "label": "requests",
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": false,
+      "dashLength": 10,
+      "dashes": false,
+      "fill": 1,
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 0
+      },
+      "id": 8,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "options": {},
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "expr": "udsproxy_http_inflight",
+          "format": "time_series",
+          "intervalFactor": 1,
+          "legendFormat": "",
+          "refId": "A"
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "udsproxy_http_inflight",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "decimals": 0,
+          "format": "short",
+          "label": "requests",
+          "logBase": 1,
+          "max": null,
+          "min": "0",
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "cards": {
+        "cardPadding": null,
+        "cardRound": null
+      },
+      "color": {
+        "cardColor": "#8AB8FF",
+        "colorScale": "sqrt",
+        "colorScheme": "interpolateBlues",
+        "exponent": 0.5,
+        "max": null,
+        "min": null,
+        "mode": "opacity"
+      },
+      "dataFormat": "tsbuckets",
+      "description": "",
+      "gridPos": {
+        "h": 7,
+        "w": 24,
+        "x": 0,
+        "y": 8
+      },
+      "heatmap": {},
+      "hideZeroBuckets": false,
+      "highlightCards": true,
+      "id": 4,
+      "legend": {
+        "show": false
+      },
+      "links": [],
+      "options": {},
+      "reverseYBuckets": false,
+      "targets": [
+        {
+          "expr": "sum(increase(udsproxy_request_duration_seconds_bucket[15s])) by (le) ",
+          "format": "heatmap",
+          "hide": false,
+          "instant": false,
+          "interval": "10s",
+          "intervalFactor": 1,
+          "legendFormat": "{{le}} s",
+          "refId": "A"
+        }
+      ],
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Request Duration",
+      "tooltip": {
+        "show": true,
+        "showHistogram": true
+      },
+      "type": "heatmap",
+      "xAxis": {
+        "show": true
+      },
+      "xBucketNumber": null,
+      "xBucketSize": null,
+      "yAxis": {
+        "decimals": null,
+        "format": "s",
+        "logBase": 1,
+        "max": null,
+        "min": "0",
+        "show": true,
+        "splitFactor": null
+      },
+      "yBucketBound": "auto",
+      "yBucketNumber": null,
+      "yBucketSize": null
+    }
+  ],
+  "refresh": "5s",
+  "schemaVersion": 18,
+  "style": "dark",
+  "tags": [],
+  "templating": {
+    "list": []
+  },
+  "time": {
+    "from": "now-30m",
+    "to": "now"
+  },
+  "timepicker": {
+    "refresh_intervals": [
+      "5s",
+      "10s",
+      "30s",
+      "1m",
+      "5m",
+      "15m",
+      "30m",
+      "1h",
+      "2h",
+      "1d"
+    ],
+    "time_options": [
+      "5m",
+      "15m",
+      "1h",
+      "6h",
+      "12h",
+      "24h",
+      "2d",
+      "7d",
+      "30d"
+    ]
+  },
+  "timezone": "",
+  "title": "uds-proxy stats",
+  "uid": "ups",
+  "version": 4
+}
diff --git a/monitoring/grafana/provisioning/dashboards/uds-proxy-dev.yaml b/monitoring/grafana/provisioning/dashboards/uds-proxy-dev.yaml
new file mode 100644
index 0000000..b7adb54
--- /dev/null
+++ b/monitoring/grafana/provisioning/dashboards/uds-proxy-dev.yaml
@@ -0,0 +1,13 @@
+apiVersion: 1
+
+providers:
+- name: 'default'
+  orgId: 1
+  folder: 'uds-proxy-dev'
+  folderUid: 'updev'
+  type: file
+  disableDeletion: false
+  editable: true
+  updateIntervalSeconds: 10
+  options:
+    path: /var/lib/grafana/dashboards
diff --git a/monitoring/grafana/provisioning/datasources/prometheus.yaml b/monitoring/grafana/provisioning/datasources/prometheus.yaml
new file mode 100644
index 0000000..4c93c69
--- /dev/null
+++ b/monitoring/grafana/provisioning/datasources/prometheus.yaml
@@ -0,0 +1,15 @@
+apiVersion: 1
+
+deleteDatasources:
+  - name: Prometheus
+    orgId: 1
+
+datasources:
+
+- name: Prometheus
+  type: prometheus
+  access: proxy
+  orgId: 1
+  url: http://prometheus:9090
+  isDefault: true
+
diff --git a/monitoring/paint_graphs.sh b/monitoring/paint_graphs.sh
new file mode 100755
index 0000000..828cbd6
--- /dev/null
+++ b/monitoring/paint_graphs.sh
@@ -0,0 +1,70 @@
+#!/bin/sh -e
+
+# run `make monitoring_test` in another shell before running this...
+# watch -n0.5 'ps aux|grep curl|egrep -v "(watch|grep)"'
+
+[ -n "$1" ] || exit 1
+TEST_SOCKET="$1"
+
+[ -n "$2" ] || exit 1
+FAKES_BASEURL="$2"
+
+CURL_WRAP=""
+if [ "$3" = "use-sudo" ]; then
+  CURL_WRAP="sudo -u nobody"
+fi
+
+
+while ! test -S "${TEST_SOCKET}"; do echo Waiting for ${TEST_SOCKET} ...; sleep 5; done
+
+paintCurl() {
+  $CURL_WRAP curl -s --unix-socket "${TEST_SOCKET}" -o /dev/null "${FAKES_BASEURL}/${1}"
+}
+
+echo
+echo "Firing some requests through uds-proxy socket towards test server in 15s...!"
+echo "Watch Grafana / http://localhost:3000/ while waiting for completion."
+echo
+sleep 15
+
+paintCurl "code/301" &
+paintCurl "code/404" &
+paintCurl "code/201" &
+
+# fixme: bring back https endpoint perf tests
+# requests via uds-proxy; requires sudo to switch to nonody account ... ugly. fix? -set-uid option?
+# python -m timeit -n 1 -r 10 -s 'import os' 'os.system("curl --unix-socket $(TEST_SOCKET) -s -o /dev/null http://hacker.ch/")'
+# requests without proxy:
+# sudo -u nobody python -m timeit -n 1 -r 10 -s 'import os' 'os.system("curl -Lso /dev/null http://hacker.ch/")'
+
+for t in $(seq 0 500 5000); do
+  paintCurl "slow/200/$t" &
+done
+
+paintCurl "code/301"
+sleep 5
+paintCurl "code/301"
+sleep 5
+paintCurl "code/302"
+
+sleep 10
+
+# default timeout is 5000, so trigger some 504s as well
+for t in $(seq 0 100 5100); do
+  paintCurl "slow/200/$t" &
+  paintCurl "slow/200/$t" &
+  paintCurl "slow/404/$t" &
+  # sleep 5-$t ?
+  sleep 5
+done
+
+echo "Waiting for background curls to complete..."
+wait
+
+sleep 5
+echo
+echo "Test graph painting completed. Feel free to fire further requests against socket, e.g."
+echo "  time $CURL_WRAP curl -v --unix-socket ${TEST_SOCKET} ${FAKES_BASEURL}/slow/200/1234"
+echo "  time $CURL_WRAP curl -v --unix-socket ${TEST_SOCKET} -o /dev/null ${FAKES_BASEURL}/size/25000"
+echo "  time $CURL_WRAP curl -v --unix-socket ${TEST_SOCKET} http://example.com/"
+echo
diff --git a/monitoring/prometheus.yml b/monitoring/prometheus.yml
new file mode 100644
index 0000000..7b1fa90
--- /dev/null
+++ b/monitoring/prometheus.yml
@@ -0,0 +1,13 @@
+global:
+  scrape_interval: 5s
+
+scrape_configs:
+  - job_name: 'prometheus'
+    static_configs:
+    - targets:
+        # prometheus should scrape itself, enables one more fancy dashboard for fun
+        - 'localhost:9090'
+        # on Mac, scrape the non-dockerized, externally running uds-proxy instance
+        - 'host.docker.internal:18080'
+        # ... and scrape the dockerized one
+        - 'udsproxy:28080'
diff --git a/proxy/metrics.go b/proxy/metrics.go
new file mode 100644
index 0000000..85d2c0e
--- /dev/null
+++ b/proxy/metrics.go
@@ -0,0 +1,57 @@
+package proxy
+
+import (
+	"log"
+	"net/http"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+type AppMetrics struct {
+	enabled          bool
+	RequestsCounter  *prometheus.CounterVec
+	RequestsInflight prometheus.Gauge
+	RequestsDuration *prometheus.HistogramVec
+}
+
+func (p *ProxyInstance) setupMetrics() {
+	p.metrics.RequestsCounter = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "udsproxy_http_requests_total",
+			Help: "How many requests processed, partitioned by status code and HTTP method.",
+		},
+		[]string{"code", "method"},
+	)
+
+	rqDurationHistogramOpts := prometheus.HistogramOpts{
+		Name:        "udsproxy_request_duration_seconds",
+		Help:        "A histogram of latencies for requests.",
+		Buckets:     []float64{.1, .2, .4, .6, .8, 1, 1.2, 1.5, 1.8, 2, 2.5, 5},
+		ConstLabels: prometheus.Labels{"handler": "proxyHandler"},
+	}
+	p.metrics.RequestsDuration = prometheus.NewHistogramVec(
+		rqDurationHistogramOpts,
+		[]string{"method"},
+	)
+
+	p.metrics.RequestsInflight = prometheus.NewGauge(prometheus.GaugeOpts{
+		Namespace: "udsproxy",
+		Subsystem: "http",
+		Name:      "inflight",
+		Help:      "Number of requests being actively processed",
+	})
+
+	prometheus.MustRegister(
+		p.metrics.RequestsDuration,
+		p.metrics.RequestsInflight,
+		p.metrics.RequestsCounter,
+	)
+	p.metrics.enabled = true
+}
+
+func (p *ProxyInstance) startPrometheusMetricsServer() {
+	log.Printf("Prometheus : http://localhost%s/metrics", p.Options.PrometheusPort)
+	http.Handle("/metrics", promhttp.Handler())
+	log.Fatal(http.ListenAndServe(p.Options.PrometheusPort, nil))
+}
diff --git a/proxy/proxy.go b/proxy/proxy.go
new file mode 100644
index 0000000..b3cff09
--- /dev/null
+++ b/proxy/proxy.go
@@ -0,0 +1,172 @@
+package proxy
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"os/signal"
+	"runtime"
+	"syscall"
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+var (
+	// AppVersion is set at compile time via make / ldflags
+	AppVersion = "0.0.0-dev"
+)
+
+type ProxyInstance struct {
+	Options    CliArgs
+	HttpClient *http.Client
+	metrics    AppMetrics
+}
+
+type CliArgs struct {
+	SocketPath          string
+	PidFile             string
+	PrometheusPort      string
+	ClientTimeout       int
+	MaxConnsPerHost     int
+	MaxIdleConns        int
+	MaxIdleConnsPerHost int
+	IdleConnTimeout     int
+	SocketReadTimeout   int
+	SocketWriteTimeout  int
+	PrintVersion        bool
+	NoLogTimeStamps     bool
+	RemoteHTTPS         bool
+}
+
+func NewProxyInstance(args CliArgs) *ProxyInstance {
+	if args.PrintVersion {
+		println("uds-proxy", AppVersion, runtime.Version())
+		os.Exit(0)
+	}
+	if args.SocketPath == "" {
+		println("Error: -socket must be provided, use -h for help")
+		os.Exit(1)
+	}
+	if args.NoLogTimeStamps {
+		log.SetFlags(0)
+	}
+	log.Printf("👋 uds-proxy %s, pid %d starting...", AppVersion, os.Getpid())
+
+	writePidFile(args.PidFile)
+
+	proxyInstance := ProxyInstance{}
+	proxyInstance.Options = args
+	if args.PrometheusPort != "" {
+		proxyInstance.setupMetrics()
+	}
+	proxyInstance.HttpClient = newHTTPClient(&proxyInstance.Options)
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	go sigHandler(c, &proxyInstance)
+
+	return &proxyInstance
+}
+
+func (p *ProxyInstance) Run() {
+	if p.metrics.enabled {
+		go p.startPrometheusMetricsServer()
+	}
+	p.startSocketServerAcceptLoop()
+}
+
+func (p *ProxyInstance) Shutdown(sig os.Signal) {
+	if sig == nil {
+		sig = os.Interrupt
+	}
+	log.Printf("%v -- cleaning up", sig)
+	p.HttpClient.CloseIdleConnections()
+	os.Remove(p.Options.SocketPath)
+	os.Remove(p.Options.PidFile)
+	log.Print("uds-proxy shut down cleanly. nice. good bye 👋")
+}
+
+func (p *ProxyInstance) startSocketServerAcceptLoop() {
+	if _, err := os.Stat(p.Options.SocketPath); err == nil {
+		err := os.Remove(p.Options.SocketPath)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+	server := http.Server{
+		ReadTimeout:  time.Duration(p.Options.SocketReadTimeout) * time.Millisecond,
+		WriteTimeout: time.Duration(p.Options.SocketWriteTimeout) * time.Millisecond,
+		Handler: func() http.HandlerFunc {
+			return p.handleProxyRequest
+		}(),
+	}
+
+	if p.metrics.enabled {
+		server.Handler = promhttp.InstrumentHandlerInFlight(p.metrics.RequestsInflight,
+			promhttp.InstrumentHandlerCounter(p.metrics.RequestsCounter,
+				promhttp.InstrumentHandlerDuration(p.metrics.RequestsDuration,
+					func() http.HandlerFunc {
+						return p.handleProxyRequest
+					}())))
+	}
+
+	unixListener, err := net.Listen("unix", p.Options.SocketPath)
+	if err != nil {
+		panic(err)
+	}
+	server.Serve(unixListener)
+}
+
+func (p *ProxyInstance) handleProxyRequest(clientResponseWriter http.ResponseWriter, clientRequest *http.Request) {
+	requestLogFormat := "%03d %d %s %s '%s'"
+	httpsS := ""
+	if p.Options.RemoteHTTPS {
+		httpsS = "s"
+
+	}
+	targetURL := fmt.Sprintf("http%s://%s%s", httpsS, clientRequest.Host, clientRequest.URL)
+
+	backendRequest, err := http.NewRequest(clientRequest.Method, targetURL, clientRequest.Body)
+	if err != nil {
+		log.Printf(requestLogFormat, 0, 0, clientRequest.Method, targetURL, err)
+		http.Error(clientResponseWriter, "500 Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+	backendRequest.Header = clientRequest.Header
+	backendRequest.Header.Set("X-Request-Via", "uds-proxy")
+
+	backendResponse, err := p.HttpClient.Do(backendRequest)
+	if err != nil {
+		log.Printf(requestLogFormat, 0, 0, clientRequest.Method, targetURL, err)
+		http.Error(clientResponseWriter, "504 Gateway Timeout", http.StatusGatewayTimeout)
+	} else {
+		for k, v := range backendResponse.Header {
+			clientResponseWriter.Header().Set(k, v[0])
+		}
+		clientResponseWriter.Header().Set("X-Response-Via", "uds-proxy")
+		clientResponseWriter.WriteHeader(backendResponse.StatusCode)
+		bytesWritten, _ := io.Copy(clientResponseWriter, backendResponse.Body)
+		log.Printf(requestLogFormat, backendResponse.StatusCode, bytesWritten, clientRequest.Method, targetURL, "")
+		backendResponse.Body.Close()
+	}
+}
+
+func newHTTPClient(opt *CliArgs) (client *http.Client) {
+	client = &http.Client{
+		Timeout: time.Duration(opt.ClientTimeout) * time.Millisecond,
+		Transport: &http.Transport{
+			MaxConnsPerHost:       opt.MaxConnsPerHost,
+			MaxIdleConns:          opt.MaxIdleConns,
+			MaxIdleConnsPerHost:   opt.MaxIdleConnsPerHost,
+			IdleConnTimeout:       time.Duration(opt.IdleConnTimeout) * time.Millisecond,
+			TLSHandshakeTimeout:   5 * time.Second,
+			ExpectContinueTimeout: 5 * time.Second,
+		},
+	}
+	return
+}
diff --git a/proxy/utility.go b/proxy/utility.go
new file mode 100644
index 0000000..3400de2
--- /dev/null
+++ b/proxy/utility.go
@@ -0,0 +1,23 @@
+package proxy
+
+import (
+	"fmt"
+	"io/ioutil"
+	"os"
+)
+
+func sigHandler(c chan os.Signal, env *ProxyInstance) {
+	for sig := range c {
+		println()
+		env.Shutdown(sig)
+		os.Exit(0)
+	}
+}
+
+func writePidFile(pidFilePath string) error {
+	if pidFilePath == "" {
+		return nil
+	}
+	data := []byte(fmt.Sprintf("%d", os.Getpid()))
+	return ioutil.WriteFile(pidFilePath, data, 0644)
+}
diff --git a/proxy_test/functional_test.go b/proxy_test/functional_test.go
new file mode 100644
index 0000000..50a0b30
--- /dev/null
+++ b/proxy_test/functional_test.go
@@ -0,0 +1,150 @@
+// +build functional
+
+package proxy_test
+
+import (
+	"context"
+	"io/ioutil"
+	"log"
+	"net"
+	"net/http"
+	"os"
+	"testing"
+	"time"
+
+	"gotest.tools/assert"
+
+	"github.com/schnoddelbotz/uds-proxy/proxy"
+	"github.com/schnoddelbotz/uds-proxy/proxy_test_server"
+)
+
+var testProxy *proxy.ProxyInstance
+
+const (
+	fakeServerPort    = ":25777"
+	fakeServerBaseURL = "http://localhost" + fakeServerPort
+	metricsPort       = ":18081"
+	metricsURL        = "http://localhost" + metricsPort + "/metrics"
+)
+
+func TestMain(m *testing.M) {
+	// create a fake upstream server with well-known responses (a la mountebank)
+	fakeServer := proxy_test_server.RunUpstreamFakeServer(fakeServerPort, true)
+	// create a single uds-proxy instance and use it for all tests in here
+	testProxy = newTestProxyInstance()
+
+	// run all tests
+	res := m.Run()
+
+	testProxy.Shutdown(nil)
+	ctx, _ := context.WithTimeout(context.Background(), 1*time.Second)
+	if err := fakeServer.Shutdown(ctx); err != nil {
+		log.Printf("fakeserver shutdown fail:s %s", err)
+	}
+	os.Exit(res)
+}
+
+func Test_RootIndexOK(t *testing.T) {
+	body, _, responseCode, err := httpGet(fakeServerBaseURL+"/", testProxy)
+
+	assert.NilError(t, err)
+	assert.Equal(t, responseCode, 200, "root / returns 200 OK")
+	assert.Equal(t, string(body), "ROOT-INDEX-OK", "root / body matches `ROOT-INDEX-OK`")
+}
+
+func Test_404Remains404(t *testing.T) {
+	_, _, responseCode, err := httpGet(fakeServerBaseURL+"/code/404", testProxy)
+
+	assert.NilError(t, err)
+	assert.Equal(t, responseCode, 404, "proxy should forward 404s")
+}
+
+func Test_TimeoutRespectedAndReportedCorrectly(t *testing.T) {
+	_, _, responseCode, err := httpGet(fakeServerBaseURL+"/slow/200/1100", testProxy)
+
+	assert.NilError(t, err)
+	assert.Equal(t, testProxy.Options.ClientTimeout, 1000)
+	assert.Equal(t, responseCode, 504, "proxy should return 504 for timeout")
+}
+
+func Test_MetricsExported(t *testing.T) {
+	_, headersNoProxy, responseCode, err := httpGet(metricsURL, nil)
+
+	assert.NilError(t, err)
+	assert.Equal(t, headersNoProxy.Get("X-Response-Via"), "")
+	assert.Equal(t, responseCode, 200, "uds-proxy should provide /metrics on -prometheus-port")
+	// tbd: match expected metrics
+}
+
+func Test_ProxyPreservesResponseHeaders(t *testing.T) {
+	// get request headers for a public website - without proxy
+	_, headersNoProxy, responseCode, err := httpGet("https://www.google.com/", nil)
+	assert.NilError(t, err)
+	assert.Equal(t, responseCode, 200)
+	assert.Equal(t, headersNoProxy.Get("X-Response-Via"), "")
+	// run same request through proxy instance
+	args := proxy.CliArgs{
+		SocketPath:  "uds-proxy-https.sock",
+		RemoteHTTPS: true,
+	}
+	httpsEnforcingProxy := proxy.NewProxyInstance(args)
+	go httpsEnforcingProxy.Run()
+	time.Sleep(250 * time.Millisecond)
+	_, headersWithProxy, responseCode, err := httpGet("http://www.google.com/", httpsEnforcingProxy)
+
+	assert.NilError(t, err)
+	assert.Equal(t, responseCode, 200)
+	assert.Equal(t, headersWithProxy.Get("X-Response-Via"), "uds-proxy")
+	for k, v := range headersNoProxy {
+		if k == "Set-Cookie" || k == "Alt-Svc" || k == "Date" {
+			continue
+		}
+		assert.Equal(t, v[0], headersWithProxy.Get(k))
+	}
+
+	httpsEnforcingProxy.Shutdown(nil)
+}
+
+// MultipleBlockingCallsDoNotBlockSocket -- 10 x go curl /slow/no-response/65000
+// TimeoutRespectedAndReportedCorrectly
+// PostDataIsPreserved
+// NotMoreThanMaxConnsAfter1000Requests
+// DoesNotLeakConnections
+// TestAllMethodsWithEchoServer
+// Test (via echo?) all headers passed /echo
+// test [post request with] echo endpoint
+// TestMetricsReportCorrectNumberOfRequests
+// check behaviour with sticky/slow client ie sock read timeout etc
+
+func httpGet(url string, proxyInstance *proxy.ProxyInstance) (body []byte, header http.Header, responseCode int, err error) {
+	client := http.Client{}
+	if proxyInstance != nil {
+		client.Transport = &http.Transport{
+			DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
+				return net.Dial("unix", proxyInstance.Options.SocketPath)
+			},
+		}
+	}
+	response, err := client.Get(url)
+	if err != nil {
+		return
+	}
+	responseCode = response.StatusCode
+	body, err = ioutil.ReadAll(response.Body)
+	header = response.Header
+	return
+}
+
+func newTestProxyInstance() *proxy.ProxyInstance {
+	args := proxy.CliArgs{
+		SocketPath:      "uds-proxy-functional_test.sock",
+		PidFile:         "uds-proxy-test.pid",
+		PrometheusPort:  metricsPort,
+		NoLogTimeStamps: true,
+		ClientTimeout:   1000,
+	}
+	e := proxy.NewProxyInstance(args)
+	go e.Run()
+	time.Sleep(250 * time.Millisecond)
+	return e
+}
diff --git a/proxy_test/unit_test.go b/proxy_test/unit_test.go
new file mode 100644
index 0000000..0f89eba
--- /dev/null
+++ b/proxy_test/unit_test.go
@@ -0,0 +1,41 @@
+// +build unit
+
+package proxy_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/schnoddelbotz/uds-proxy/proxy"
+)
+
+const testSocketFilename = "uds-proxy-unit-test.sock"
+
+func Test_Create(t *testing.T) {
+	e := proxy.NewProxyInstance(proxy.CliArgs{SocketPath: testSocketFilename})
+
+	assert.False(t, e.Options.RemoteHTTPS)
+	assert.Equal(t, e.Options.SocketPath, testSocketFilename)
+	e.Shutdown(nil)
+}
+
+func Test_HttpClientUsesEnvArgs(t *testing.T) {
+	testTimeout := 500
+	e := proxy.NewProxyInstance(proxy.CliArgs{SocketPath: testSocketFilename, ClientTimeout: testTimeout, MaxIdleConns: 11})
+
+	assert.Equal(t, e.HttpClient.Timeout, time.Duration(testTimeout)*time.Millisecond)
+	e.Shutdown(nil)
+}
+
+func Test_EnvArgumentRemoteHTTPSArrivesInOptions(t *testing.T) {
+	e := proxy.NewProxyInstance(proxy.CliArgs{SocketPath: testSocketFilename, RemoteHTTPS: true})
+
+	assert.Equal(t, e.Options.RemoteHTTPS, true)
+	e.Shutdown(nil)
+}
+
+func Test_AppVersionDefined(t *testing.T) {
+	assert.NotEqual(t, proxy.AppVersion, "0.0.0-dev")
+}
diff --git a/proxy_test_server/README.md b/proxy_test_server/README.md
new file mode 100644
index 0000000..c38136b
--- /dev/null
+++ b/proxy_test_server/README.md
@@ -0,0 +1,7 @@
+# proxy_test_server
+
+... is instantiated by [functional tests](../proxy_test/functional_test.go) to 
+simulate a backend server for uds-proxy tests.
+In a way, it's this project's 'embedded' [mountebank](http://www.mbtest.org).
+
+To build a binary, run `make test_server`.
\ No newline at end of file
diff --git a/proxy_test_server/server.go b/proxy_test_server/server.go
new file mode 100644
index 0000000..43b75d9
--- /dev/null
+++ b/proxy_test_server/server.go
@@ -0,0 +1,103 @@
+package proxy_test_server
+
+import (
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type RandomReader struct {
+	toRead  int
+	written int
+}
+
+func RunUpstreamFakeServer(port string, fork bool) *http.Server {
+	log.Printf("Starting fake upstream server for functional tests on %s", port)
+	srv := &http.Server{Addr: port}
+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		io.WriteString(w, "ROOT-INDEX-OK")
+	})
+
+	http.HandleFunc("/slow/", func(w http.ResponseWriter, r *http.Request) {
+		params := strings.Split(strings.Replace(r.URL.Path, "/slow/", "", 1), "/")
+		if len(params) < 2 {
+			http.Error(w, "Bad usage", http.StatusBadRequest)
+			return
+		}
+		code, _ := strconv.Atoi(params[0])
+		delay, _ := strconv.Atoi(params[1])
+		message := http.StatusText(code)
+		if message == "" {
+			code = http.StatusBadRequest
+			message = http.StatusText(code)
+		}
+		time.Sleep(time.Duration(delay) * time.Millisecond)
+		http.Error(w, message, code)
+	})
+
+	http.HandleFunc("/slow/no-response/", func(w http.ResponseWriter, r *http.Request) {
+		delay, _ := strconv.Atoi(strings.Replace(r.URL.Path, "/slow/no-response/", "", 1))
+		time.Sleep(time.Duration(delay) * time.Millisecond)
+		// find a nicer way...?
+		panic("Believe I need to panic to create empty response")
+	})
+
+	http.HandleFunc("/code/", func(w http.ResponseWriter, r *http.Request) {
+		code, _ := strconv.Atoi(strings.Replace(r.URL.Path, "/code/", "", 1))
+		message := http.StatusText(code)
+		if message == "" {
+			code = http.StatusBadRequest
+			message = http.StatusText(code)
+		}
+		http.Error(w, message, code)
+	})
+
+	http.HandleFunc("/size/", func(w http.ResponseWriter, r *http.Request) {
+		size, _ := strconv.Atoi(strings.Replace(r.URL.Path, "/size/", "", 1))
+		w.Header().Set("Content-Length", strconv.Itoa(size))
+		io.Copy(w, io.LimitReader(NewRandomReaderWithSizeLimit(size), int64(size)))
+	})
+
+	http.HandleFunc("/shutdown", func(w http.ResponseWriter, r *http.Request) {
+		io.WriteString(w, "Fakeserver says ciao!")
+		go func() {
+			time.Sleep(250 * time.Millisecond)
+			os.Exit(0)
+		}()
+	})
+
+	if fork {
+		go func() {
+			if err := srv.ListenAndServe(); err != http.ErrServerClosed {
+				log.Fatalf("ListenAndServe(): %s", err)
+			}
+		}()
+		time.Sleep(250 * time.Millisecond)
+	} else {
+		err := srv.ListenAndServe()
+		log.Fatalf("ListenAndServe(): %s", err)
+	}
+
+	return srv
+}
+
+func NewRandomReaderWithSizeLimit(limit int) *RandomReader {
+	return &RandomReader{limit, 0}
+}
+
+func (r *RandomReader) Read(p []byte) (n int, err error) {
+	bufSize := len(p)
+	for i := 0; i < bufSize; i++ {
+		p[i] = 'X' // not supposed to be random. just fill bandwidth :)
+	}
+	r.written = r.written + bufSize
+	if r.written >= r.toRead {
+		return bufSize, io.EOF
+	}
+	return bufSize, nil
+}
diff --git a/proxy_test_server/test_server.Dockerfile b/proxy_test_server/test_server.Dockerfile
new file mode 100644
index 0000000..f2df551
--- /dev/null
+++ b/proxy_test_server/test_server.Dockerfile
@@ -0,0 +1,15 @@
+
+FROM golang:1.12.5 as build-env
+WORKDIR /src/github.com/schnoddelbotz/uds-proxy
+COPY . .
+RUN make clean test_server CGO_ENABLED=0
+
+FROM alpine
+COPY --from=build-env /src/github.com/schnoddelbotz/uds-proxy/test_server /bin/test_server
+
+ENTRYPOINT []
+ENV TEST_SERVER_PORT=25777
+EXPOSE ${TEST_SERVER_PORT}
+
+USER nobody
+CMD test_server -port :${TEST_SERVER_PORT}
diff --git a/uds-proxy.Dockerfile b/uds-proxy.Dockerfile
new file mode 100644
index 0000000..7c92b21
--- /dev/null
+++ b/uds-proxy.Dockerfile
@@ -0,0 +1,17 @@
+
+FROM golang:1.12.5 as build-env
+WORKDIR /src/github.com/schnoddelbotz/uds-proxy
+COPY . .
+RUN make test clean uds-proxy CGO_ENABLED=0
+
+FROM alpine
+RUN apk add ca-certificates
+COPY --from=build-env /src/github.com/schnoddelbotz/uds-proxy/uds-proxy /bin/uds-proxy
+
+ENTRYPOINT []
+ENV UDS_PROXY_DOCKER_SOCKET_PATH=/tmp/uds-proxy-docker.sock
+ENV UDS_PROXY_DOCKER_PROMETHEUS_PORT=28080
+EXPOSE ${UDS_PROXY_DOCKER_PROMETHEUS_PORT}
+
+USER nobody
+CMD uds-proxy -socket ${UDS_PROXY_DOCKER_SOCKET_PATH} -prometheus-port :${UDS_PROXY_DOCKER_PROMETHEUS_PORT}