Merge pull request #386 from mumoshu/envoy-canary-analysis

feat: Support for canary analysis on deployments and services behind Envoy
2019-12-18 19:22:18 +02:00 · 2019-12-18 19:22:18 +02:00 · 968d67a7c3
parent 3ff0786e1f 266b957fc6
commit 968d67a7c3
13 changed files with 1887 additions and 25 deletions
--- a/README.md
+++ b/README.md
@ -41,6 +41,7 @@ Flagger documentation can be found at [docs.flagger.app](https://docs.flagger.ap
  * [Istio canary deployments](https://docs.flagger.app/usage/progressive-delivery)
  * [Linkerd canary deployments](https://docs.flagger.app/usage/linkerd-progressive-delivery)
  * [App Mesh canary deployments](https://docs.flagger.app/usage/appmesh-progressive-delivery)
+  * [Crossover canary deployments](https://docs.flagger.app/usage/crossover-progressive-delivery)
  * [NGINX ingress controller canary deployments](https://docs.flagger.app/usage/nginx-progressive-delivery)
  * [Gloo ingress controller canary deployments](https://docs.flagger.app/usage/gloo-progressive-delivery)
  * [Blue/Green deployments](https://docs.flagger.app/usage/blue-green)
--- a/charts/grafana/dashboards/envoy.json
+++ b/charts/grafana/dashboards/envoy.json
--- a/cmd/flagger/main.go
+++ b/cmd/flagger/main.go
@ -161,7 +161,7 @@ func main() {
 		logger.Infof("Watching namespace %s", namespace)
 	}

-	observerFactory, err := metrics.NewFactory(metricsServer, meshProvider, 5*time.Second)
+	observerFactory, err := metrics.NewFactory(metricsServer, 5*time.Second)
 	if err != nil {
 		logger.Fatalf("Error building prometheus client: %s", err.Error())
 	}
--- a/docs/gitbook/usage/crossover-progressive-delivery.md
+++ b/docs/gitbook/usage/crossover-progressive-delivery.md
@ -0,0 +1,319 @@
+# Envoy/Crossover Canary Deployments
+
+This guide shows you how to use Envoy, [Crossover](https://github.com/mumoshu/crossover) and Flagger to automate canary deployments.
+
+Crossover is a minimal Envoy xDS implementation supports [Service Mesh Interface](https://smi-spec.io/).
+
+### Prerequisites
+
+Flagger requires a Kubernetes cluster **v1.11** or newer and Envoy paired with [Crossover](https://github.com/mumoshu/crossover) sidecar.
+
+Create a test namespace:
+
+```bash
+kubectl create ns test
+```
+
+Install Envoy along with the Crossover sidecar with Helm:
+
+```bash
+helm repo add crossover https://mumoshu.github.io/crossover
+
+helm upgrade --install envoy crossover/envoy \
+  --namespace test \
+  -f <(cat <<EOF
+smi:
+  apiVersions:
+    trafficSplits: v1alpha1
+upstreams:
+  podinfo:
+    smi:
+      enabled: true
+    backends:
+      podinfo-primary:
+        port: 9898
+        weight: 100
+      podinfo-canary:
+        port: 9898
+        weight: 0
+EOF
+)
+```
+
+Install Flagger and the Prometheus add-on in the same namespace as Envoy:
+
+```bash
+helm repo add flagger https://flagger.app
+
+helm upgrade -i flagger flagger/flagger \
+--namespace test \
+--set prometheus.install=true \
+--set meshProvider=smi:crossover
+```
+
+Optionally you can enable Slack notifications:
+
+```bash
+helm upgrade -i flagger flagger/flagger \
+--reuse-values \
+--namespace test \
+--set slack.url=https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK \
+--set slack.channel=general \
+--set slack.user=flagger
+```
+
+### Bootstrap
+
+Flagger takes a Kubernetes deployment and optionally a horizontal pod autoscaler (HPA), 
+then creates a series of objects (Kubernetes deployments, ClusterIP services, SMI traffic splits). 
+These objects expose the application on the mesh and drive the canary analysis and promotion.
+There's no SMI object you need to create by yourself.
+
+Create a deployment and a horizontal pod autoscaler:
+
+```bash
+kubectl apply -k github.com/weaveworks/flagger//kustomize/podinfo
+```
+
+Deploy the load testing service to generate traffic during the canary analysis:
+
+```bash
+helm upgrade -i flagger-loadtester flagger/loadtester \
+--namespace=test
+```
+
+Create a canary custom resource:
+
+```yaml
+apiVersion: flagger.app/v1alpha3
+kind: Canary
+metadata:
+  name: podinfo
+  namespace: test
+spec:
+  # specify mesh provider if it isn't the default one
+  # provider: "smi:crossover"
+  # deployment reference
+  targetRef:
+    apiVersion: apps/v1
+    kind: Deployment
+    name: podinfo
+  # the maximum time in seconds for the canary deployment
+  # to make progress before it is rollback (default 600s)
+  progressDeadlineSeconds: 60
+  # HPA reference (optional)
+  autoscalerRef:
+    apiVersion: autoscaling/v2beta1
+    kind: HorizontalPodAutoscaler
+    name: podinfo
+  service:
+    # ClusterIP port number
+    port: 9898
+    # container port number or name (optional)
+    targetPort: 9898
+  # define the canary analysis timing and KPIs
+  canaryAnalysis:
+    # schedule interval (default 60s)
+    interval: 1m
+    # max number of failed metric checks before rollback
+    threshold: 5
+    # max traffic percentage routed to canary
+    # percentage (0-100)
+    maxWeight: 50
+    # canary increment step
+    # percentage (0-100)
+    stepWeight: 5
+    # App Mesh Prometheus checks
+    metrics:
+    - name: request-success-rate
+      # minimum req success rate (non 5xx responses)
+      # percentage (0-100)
+      threshold: 99
+      interval: 1m
+    - name: request-duration
+      # maximum req duration P99
+      # milliseconds
+      threshold: 500
+      interval: 30s
+    # testing (optional)
+    webhooks:
+    - name: acceptance-test
+      type: pre-rollout
+      url: http://flagger-loadtester.test/
+      timeout: 30s
+      metadata:
+        type: bash
+        cmd: "curl -sd 'test' http://podinfo-canary.test:9898/token | grep token"
+    - name: load-test
+      url: http://flagger-loadtester.test/
+      timeout: 5s
+      metadata:
+        cmd: "hey -z 1m -q 10 -c 2 -H 'Host: podinfo.test' http://envoy.test:10000/"
+```
+
+Save the above resource as podinfo-canary.yaml and then apply it:
+
+```bash
+kubectl apply -f ./podinfo-canary.yaml
+```
+
+After a couple of seconds Flagger will create the canary objects:
+
+```bash
+# applied 
+deployment.apps/podinfo
+horizontalpodautoscaler.autoscaling/podinfo
+canary.flagger.app/podinfo
+
+# generated
+deployment.apps/podinfo-primary
+horizontalpodautoscaler.autoscaling/podinfo-primary
+service/podinfo
+service/podinfo-canary
+service/podinfo-primary
+trafficsplits.split.smi-spec.io/podinfo
+```
+
+After the boostrap, the podinfo deployment will be scaled to zero and the traffic to `podinfo.test` will be routed
+to the primary pods. During the canary analysis, the `podinfo-canary.test` address can be used to target directly the canary pods.
+
+### Automated canary promotion
+
+Flagger implements a control loop that gradually shifts traffic to the canary while measuring key performance indicators like HTTP requests success rate, requests average duration and pod health. Based on analysis of the KPIs a canary is promoted or aborted, and the analysis result is published to Slack.
+
+![Flagger Canary Stages](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-canary-steps.png)
+
+A canary deployment is triggered by changes in any of the following objects:
+
+* Deployment PodSpec (container image, command, ports, env, resources, etc)
+* ConfigMaps and Secrets mounted as volumes or mapped to environment variables
+
+Trigger a canary deployment by updating the container image:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.5
+```
+
+Flagger detects that the deployment revision changed and starts a new rollout:
+
+```text
+kubectl -n test describe canary/podinfo
+
+Status:
+  Canary Weight:         0
+  Failed Checks:         0
+  Phase:                 Succeeded
+Events:
+ New revision detected! Scaling up podinfo.test
+ Waiting for podinfo.test rollout to finish: 0 of 1 updated replicas are available
+ Pre-rollout check acceptance-test passed
+ Advance podinfo.test canary weight 5
+ Advance podinfo.test canary weight 10
+ Advance podinfo.test canary weight 15
+ Advance podinfo.test canary weight 20
+ Advance podinfo.test canary weight 25
+ Advance podinfo.test canary weight 30
+ Advance podinfo.test canary weight 35
+ Advance podinfo.test canary weight 40
+ Advance podinfo.test canary weight 45
+ Advance podinfo.test canary weight 50
+ Copying podinfo.test template spec to podinfo-primary.test
+ Waiting for podinfo-primary.test rollout to finish: 1 of 2 updated replicas are available
+ Routing all traffic to primary
+ Promotion completed! Scaling down podinfo.test
+```
+
+When the canary analysis starts, Flagger will call the pre-rollout webhooks before routing traffic to the canary.
+
+**Note** that if you apply new changes to the deployment during the canary analysis, Flagger will restart the analysis.
+
+During the analysis the canary’s progress can be monitored with Grafana.
+
+Flagger comes with a Grafana dashboard made for canary analysis. Install Grafana with Helm:
+
+```bash
+helm upgrade -i flagger-grafana flagger/grafana \
+--namespace=test \
+--set url=http://flagger-prometheus:9090
+```
+
+Run:
+
+```bash
+kubectl port-forward --namespace test svc/flagger-grafana 3000:80
+```
+
+The Envoy dashboard URL is 
+http://localhost:3000/d/flagger-envoy/envoy-canary?refresh=10s&orgId=1&var-namespace=test&var-target=podinfo
+
+![Envoy Canary Dashboard](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/flagger-grafana-appmesh.png)
+
+You can monitor all canaries with:
+
+```bash
+watch kubectl get canaries --all-namespaces
+
+NAMESPACE   NAME      STATUS        WEIGHT   LASTTRANSITIONTIME
+test        podinfo   Progressing   15       2019-10-02T14:05:07Z
+prod        frontend  Succeeded     0        2019-10-02T16:15:07Z
+prod        backend   Failed        0        2019-10-02T17:05:07Z
+```
+
+If you’ve enabled the Slack notifications, you should receive the following messages:
+
+![Flagger Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-notifications.png)
+
+### Automated rollback
+
+During the canary analysis you can generate HTTP 500 errors or high latency to test if Flagger pauses the rollout.
+
+Trigger a canary deployment:
+
+```bash
+kubectl -n test set image deployment/podinfo \
+podinfod=stefanprodan/podinfo:3.1.2
+```
+
+Exec into the load tester pod with:
+
+```bash
+kubectl -n test exec -it deploy/flagger-loadtester bash
+```
+
+Generate HTTP 500 errors:
+
+```bash
+hey -z 1m -c 5 -q 5 -H 'Host: podinfo.test' http://envoy.test:10000/status/500
+```
+
+Generate latency:
+
+```bash
+watch -n 1 curl -H 'Host: podinfo.test' http://envoy.test:10000/delay/1
+```
+
+When the number of failed checks reaches the canary analysis threshold, the traffic is routed back to the primary, 
+the canary is scaled to zero and the rollout is marked as failed.
+
+```text
+kubectl -n test logs deploy/flagger -f | jq .msg
+
+New revision detected! Starting canary analysis for podinfo.test
+Pre-rollout check acceptance-test passed
+Advance podinfo.test canary weight 5
+Advance podinfo.test canary weight 10
+Advance podinfo.test canary weight 15
+Halt podinfo.test advancement success rate 69.17% < 99%
+Halt podinfo.test advancement success rate 61.39% < 99%
+Halt podinfo.test advancement success rate 55.06% < 99%
+Halt podinfo.test advancement request duration 1.20s > 0.5s
+Halt podinfo.test advancement request duration 1.45s > 0.5s
+Rolling back podinfo.test failed checks threshold reached 5
+Canary failed! Scaling down podinfo.test
+```
+
+If you’ve enabled the Slack notifications, you’ll receive a message if the progress deadline is exceeded, 
+or if the analysis reached the maximum number of failed checks:
+
+![Flagger Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-failed.png)
--- a/pkg/controller/controller_test.go
+++ b/pkg/controller/controller_test.go
@ -73,7 +73,7 @@ func SetupMocks(c *flaggerv1.Canary) Mocks {
 	rf := router.NewFactory(nil, kubeClient, flaggerClient, "annotationsPrefix", logger, flaggerClient)

 	// init observer
-	observerFactory, _ := metrics.NewFactory("fake", "istio", 5*time.Second)
+	observerFactory, _ := metrics.NewFactory("fake", 5*time.Second)

 	// init canary factory
 	configTracker := canary.ConfigTracker{
--- a/pkg/controller/scheduler.go
+++ b/pkg/controller/scheduler.go
@ -13,6 +13,10 @@ import (
 	"github.com/weaveworks/flagger/pkg/router"
 )

+const (
+	MetricsProviderServiceSuffix = ":service"
+)
+
 // scheduleCanaries synchronises the canary map with the jobs map,
 // for new canaries new jobs are created and started
 // for the removed canaries the jobs are stopped and deleted
@ -761,15 +765,27 @@ func (c *Controller) runAnalysis(r *flaggerv1.Canary) bool {
 	}

 	// override the global provider if one is specified in the canary spec
-	metricsProvider := c.meshProvider
+	var metricsProvider string
+	// set the metrics provider to Crossover Prometheus when Crossover is the mesh provider
+	// For example, `crossover` metrics provider should be used for `smi:crossover` mesh provider
+	if strings.Contains(c.meshProvider, "crossover") {
+		metricsProvider = "crossover"
+	} else {
+		metricsProvider = c.meshProvider
+	}
+
 	if r.Spec.Provider != "" {
 		metricsProvider = r.Spec.Provider

-		// set the metrics server to Linkerd Prometheus when Linkerd is the default mesh provider
+		// set the metrics provider to Linkerd Prometheus when Linkerd is the default mesh provider
 		if strings.Contains(c.meshProvider, "linkerd") {
 			metricsProvider = "linkerd"
 		}
 	}
+	// set the metrics provider to query Prometheus for the canary Kubernetes service if the canary target is Service
+	if r.Spec.TargetRef.Kind == "Service" {
+		metricsProvider = metricsProvider + MetricsProviderServiceSuffix
+	}

 	// create observer based on the mesh provider
 	observerFactory := c.observerFactory
@ -779,7 +795,7 @@ func (c *Controller) runAnalysis(r *flaggerv1.Canary) bool {
 	if r.Spec.MetricsServer != "" {
 		metricsServer = r.Spec.MetricsServer
 		var err error
-		observerFactory, err = metrics.NewFactory(metricsServer, metricsProvider, 5*time.Second)
+		observerFactory, err = metrics.NewFactory(metricsServer, 5*time.Second)
 		if err != nil {
 			c.recordEventErrorf(r, "Error building Prometheus client for %s %v", r.Spec.MetricsServer, err)
 			return false
@ -797,8 +813,8 @@ func (c *Controller) runAnalysis(r *flaggerv1.Canary) bool {
 			val, err := observer.GetRequestSuccessRate(r.Spec.TargetRef.Name, r.Namespace, metric.Interval)
 			if err != nil {
 				if strings.Contains(err.Error(), "no values found") {
-					c.recordEventWarningf(r, "Halt advancement no values found for metric %s probably %s.%s is not receiving traffic",
-						metric.Name, r.Spec.TargetRef.Name, r.Namespace)
+					c.recordEventWarningf(r, "Halt advancement no values found for %s metric %s probably %s.%s is not receiving traffic",
+						metricsProvider, metric.Name, r.Spec.TargetRef.Name, r.Namespace)
 				} else {
 					c.recordEventErrorf(r, "Metrics server %s query failed: %v", metricsServer, err)
 				}
@ -817,8 +833,8 @@ func (c *Controller) runAnalysis(r *flaggerv1.Canary) bool {
 			val, err := observer.GetRequestDuration(r.Spec.TargetRef.Name, r.Namespace, metric.Interval)
 			if err != nil {
 				if strings.Contains(err.Error(), "no values found") {
-					c.recordEventWarningf(r, "Halt advancement no values found for metric %s probably %s.%s is not receiving traffic",
-						metric.Name, r.Spec.TargetRef.Name, r.Namespace)
+					c.recordEventWarningf(r, "Halt advancement no values found for %s metric %s probably %s.%s is not receiving traffic",
+						metricsProvider, metric.Name, r.Spec.TargetRef.Name, r.Namespace)
 				} else {
 					c.recordEventErrorf(r, "Metrics server %s query failed: %v", metricsServer, err)
 				}
--- a/pkg/metrics/appmesh.go
+++ b/pkg/metrics/appmesh.go
@ -4,7 +4,7 @@ import (
 	"time"
 )

-var envoyQueries = map[string]string{
+var appMeshQueries = map[string]string{
 	"request-success-rate": `
 	sum(
 		rate(
@ -39,12 +39,12 @@ var envoyQueries = map[string]string{
 	)`,
 }

-type EnvoyObserver struct {
+type AppMeshObserver struct {
 	client *PrometheusClient
 }

-func (ob *EnvoyObserver) GetRequestSuccessRate(name string, namespace string, interval string) (float64, error) {
-	query, err := ob.client.RenderQuery(name, namespace, interval, envoyQueries["request-success-rate"])
+func (ob *AppMeshObserver) GetRequestSuccessRate(name string, namespace string, interval string) (float64, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, appMeshQueries["request-success-rate"])
 	if err != nil {
 		return 0, err
 	}
@ -57,8 +57,8 @@ func (ob *EnvoyObserver) GetRequestSuccessRate(name string, namespace string, in
 	return value, nil
 }

-func (ob *EnvoyObserver) GetRequestDuration(name string, namespace string, interval string) (time.Duration, error) {
-	query, err := ob.client.RenderQuery(name, namespace, interval, envoyQueries["request-duration"])
+func (ob *AppMeshObserver) GetRequestDuration(name string, namespace string, interval string) (time.Duration, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, appMeshQueries["request-duration"])
 	if err != nil {
 		return 0, err
 	}
--- a/pkg/metrics/appmesh_test.go
+++ b/pkg/metrics/appmesh_test.go
@ -7,7 +7,7 @@ import (
 	"time"
 )

-func TestEnvoyObserver_GetRequestSuccessRate(t *testing.T) {
+func TestAppMeshObserver_GetRequestSuccessRate(t *testing.T) {
 	expected := ` sum( rate( envoy_cluster_upstream_rq{ kubernetes_namespace="default", kubernetes_pod_name=~"podinfo-[0-9a-zA-Z]+(-[0-9a-zA-Z]+)", envoy_response_code!~"5.*" }[1m] ) ) / sum( rate( envoy_cluster_upstream_rq{ kubernetes_namespace="default", kubernetes_pod_name=~"podinfo-[0-9a-zA-Z]+(-[0-9a-zA-Z]+)" }[1m] ) ) * 100`

 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@ -26,7 +26,7 @@ func TestEnvoyObserver_GetRequestSuccessRate(t *testing.T) {
 		t.Fatal(err)
 	}

-	observer := &EnvoyObserver{
+	observer := &AppMeshObserver{
 		client: client,
 	}

@ -40,7 +40,7 @@ func TestEnvoyObserver_GetRequestSuccessRate(t *testing.T) {
 	}
 }

-func TestEnvoyObserver_GetRequestDuration(t *testing.T) {
+func TestAppMeshObserver_GetRequestDuration(t *testing.T) {
 	expected := ` histogram_quantile( 0.99, sum( rate( envoy_cluster_upstream_rq_time_bucket{ kubernetes_namespace="default", kubernetes_pod_name=~"podinfo-[0-9a-zA-Z]+(-[0-9a-zA-Z]+)" }[1m] ) ) by (le) )`

 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@ -59,7 +59,7 @@ func TestEnvoyObserver_GetRequestDuration(t *testing.T) {
 		t.Fatal(err)
 	}

-	observer := &EnvoyObserver{
+	observer := &AppMeshObserver{
 		client: client,
 	}

--- a/pkg/metrics/crossover.go
+++ b/pkg/metrics/crossover.go
@ -0,0 +1,73 @@
+package metrics
+
+import (
+	"time"
+)
+
+var crossoverQueries = map[string]string{
+	"request-success-rate": `
+	sum(
+		rate(
+			envoy_cluster_upstream_rq{
+				kubernetes_namespace="{{ .Namespace }}",
+				envoy_cluster_name=~"{{ .Name }}-canary",
+				envoy_response_code!~"5.*"
+			}[{{ .Interval }}]
+		)
+	) 
+	/ 
+	sum(
+		rate(
+			envoy_cluster_upstream_rq{
+				kubernetes_namespace="{{ .Namespace }}",
+				envoy_cluster_name=~"{{ .Name }}-canary"
+			}[{{ .Interval }}]
+		)
+	) 
+	* 100`,
+	"request-duration": `
+	histogram_quantile(
+		0.99,
+		sum(
+			rate(
+				envoy_cluster_upstream_rq_time_bucket{
+					kubernetes_namespace="{{ .Namespace }}",
+					envoy_cluster_name=~"{{ .Name }}-canary"
+				}[{{ .Interval }}]
+			)
+		) by (le)
+	)`,
+}
+
+type CrossoverObserver struct {
+	client *PrometheusClient
+}
+
+func (ob *CrossoverObserver) GetRequestSuccessRate(name string, namespace string, interval string) (float64, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, crossoverQueries["request-success-rate"])
+	if err != nil {
+		return 0, err
+	}
+
+	value, err := ob.client.RunQuery(query)
+	if err != nil {
+		return 0, err
+	}
+
+	return value, nil
+}
+
+func (ob *CrossoverObserver) GetRequestDuration(name string, namespace string, interval string) (time.Duration, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, crossoverQueries["request-duration"])
+	if err != nil {
+		return 0, err
+	}
+
+	value, err := ob.client.RunQuery(query)
+	if err != nil {
+		return 0, err
+	}
+
+	ms := time.Duration(int64(value)) * time.Millisecond
+	return ms, nil
+}
--- a/pkg/metrics/crossover_service.go
+++ b/pkg/metrics/crossover_service.go
@ -0,0 +1,73 @@
+package metrics
+
+import (
+	"time"
+)
+
+var crossoverServiceQueries = map[string]string{
+	"request-success-rate": `
+	sum(
+		rate(
+			envoy_cluster_upstream_rq{
+				kubernetes_namespace="{{ .Namespace }}",
+				envoy_cluster_name="{{ .Name }}-canary",
+				envoy_response_code!~"5.*"
+			}[{{ .Interval }}]
+		)
+	) 
+	/ 
+	sum(
+		rate(
+			envoy_cluster_upstream_rq{
+				kubernetes_namespace="{{ .Namespace }}",
+				envoy_cluster_name="{{ .Name }}-canary"
+			}[{{ .Interval }}]
+		)
+	) 
+	* 100`,
+	"request-duration": `
+	histogram_quantile(
+		0.99,
+		sum(
+			rate(
+				envoy_cluster_upstream_rq_time_bucket{
+					kubernetes_namespace="{{ .Namespace }}",
+					envoy_cluster_name="{{ .Name }}-canary"
+				}[{{ .Interval }}]
+			)
+		) by (le)
+	)`,
+}
+
+type CrossoverServiceObserver struct {
+	client *PrometheusClient
+}
+
+func (ob *CrossoverServiceObserver) GetRequestSuccessRate(name string, namespace string, interval string) (float64, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, crossoverServiceQueries["request-success-rate"])
+	if err != nil {
+		return 0, err
+	}
+
+	value, err := ob.client.RunQuery(query)
+	if err != nil {
+		return 0, err
+	}
+
+	return value, nil
+}
+
+func (ob *CrossoverServiceObserver) GetRequestDuration(name string, namespace string, interval string) (time.Duration, error) {
+	query, err := ob.client.RenderQuery(name, namespace, interval, crossoverServiceQueries["request-duration"])
+	if err != nil {
+		return 0, err
+	}
+
+	value, err := ob.client.RunQuery(query)
+	if err != nil {
+		return 0, err
+	}
+
+	ms := time.Duration(int64(value)) * time.Millisecond
+	return ms, nil
+}
--- a/pkg/metrics/crossover_service_test.go
+++ b/pkg/metrics/crossover_service_test.go
@ -0,0 +1,74 @@
+package metrics
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func TestCrossoverServiceObserver_GetRequestSuccessRate(t *testing.T) {
+	expected := ` sum( rate( envoy_cluster_upstream_rq{ kubernetes_namespace="default", envoy_cluster_name="podinfo-canary", envoy_response_code!~"5.*" }[1m] ) ) / sum( rate( envoy_cluster_upstream_rq{ kubernetes_namespace="default", envoy_cluster_name="podinfo-canary" }[1m] ) ) * 100`
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		promql := r.URL.Query()["query"][0]
+		if promql != expected {
+			t.Errorf("\nGot %s \nWanted %s", promql, expected)
+		}
+
+		json := `{"status":"success","data":{"resultType":"vector","result":[{"metric":{},"value":[1,"100"]}]}}`
+		w.Write([]byte(json))
+	}))
+	defer ts.Close()
+
+	client, err := NewPrometheusClient(ts.URL, time.Second)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	observer := &CrossoverServiceObserver{
+		client: client,
+	}
+
+	val, err := observer.GetRequestSuccessRate("podinfo", "default", "1m")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if val != 100 {
+		t.Errorf("Got %v wanted %v", val, 100)
+	}
+}
+
+func TestCrossoverServiceObserver_GetRequestDuration(t *testing.T) {
+	expected := ` histogram_quantile( 0.99, sum( rate( envoy_cluster_upstream_rq_time_bucket{ kubernetes_namespace="default", envoy_cluster_name="podinfo-canary" }[1m] ) ) by (le) )`
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		promql := r.URL.Query()["query"][0]
+		if promql != expected {
+			t.Errorf("\nGot %s \nWanted %s", promql, expected)
+		}
+
+		json := `{"status":"success","data":{"resultType":"vector","result":[{"metric":{},"value":[1,"100"]}]}}`
+		w.Write([]byte(json))
+	}))
+	defer ts.Close()
+
+	client, err := NewPrometheusClient(ts.URL, time.Second)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	observer := &CrossoverServiceObserver{
+		client: client,
+	}
+
+	val, err := observer.GetRequestDuration("podinfo", "default", "1m")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if val != 100*time.Millisecond {
+		t.Errorf("Got %v wanted %v", val, 100*time.Millisecond)
+	}
+}
--- a/pkg/metrics/crossover_test.go
+++ b/pkg/metrics/crossover_test.go
@ -0,0 +1,74 @@
+package metrics
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func TestCrossoverObserver_GetRequestSuccessRate(t *testing.T) {
+	expected := ` sum( rate( envoy_cluster_upstream_rq{ kubernetes_namespace="default", envoy_cluster_name=~"podinfo-canary", envoy_response_code!~"5.*" }[1m] ) ) / sum( rate( envoy_cluster_upstream_rq{ kubernetes_namespace="default", envoy_cluster_name=~"podinfo-canary" }[1m] ) ) * 100`
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		promql := r.URL.Query()["query"][0]
+		if promql != expected {
+			t.Errorf("\nGot %s \nWanted %s", promql, expected)
+		}
+
+		json := `{"status":"success","data":{"resultType":"vector","result":[{"metric":{},"value":[1,"100"]}]}}`
+		w.Write([]byte(json))
+	}))
+	defer ts.Close()
+
+	client, err := NewPrometheusClient(ts.URL, time.Second)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	observer := &CrossoverObserver{
+		client: client,
+	}
+
+	val, err := observer.GetRequestSuccessRate("podinfo", "default", "1m")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if val != 100 {
+		t.Errorf("Got %v wanted %v", val, 100)
+	}
+}
+
+func TestCrossoverObserver_GetRequestDuration(t *testing.T) {
+	expected := ` histogram_quantile( 0.99, sum( rate( envoy_cluster_upstream_rq_time_bucket{ kubernetes_namespace="default", envoy_cluster_name=~"podinfo-canary" }[1m] ) ) by (le) )`
+
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		promql := r.URL.Query()["query"][0]
+		if promql != expected {
+			t.Errorf("\nGot %s \nWanted %s", promql, expected)
+		}
+
+		json := `{"status":"success","data":{"resultType":"vector","result":[{"metric":{},"value":[1,"100"]}]}}`
+		w.Write([]byte(json))
+	}))
+	defer ts.Close()
+
+	client, err := NewPrometheusClient(ts.URL, time.Second)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	observer := &CrossoverObserver{
+		client: client,
+	}
+
+	val, err := observer.GetRequestDuration("podinfo", "default", "1m")
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if val != 100*time.Millisecond {
+		t.Errorf("Got %v wanted %v", val, 100*time.Millisecond)
+	}
+}
--- a/pkg/metrics/factory.go
+++ b/pkg/metrics/factory.go
@ -6,19 +6,17 @@ import (
 )

 type Factory struct {
-	MeshProvider string
-	Client       *PrometheusClient
+	Client *PrometheusClient
 }

-func NewFactory(metricsServer string, meshProvider string, timeout time.Duration) (*Factory, error) {
+func NewFactory(metricsServer string, timeout time.Duration) (*Factory, error) {
 	client, err := NewPrometheusClient(metricsServer, timeout)
 	if err != nil {
 		return nil, err
 	}

 	return &Factory{
-		MeshProvider: meshProvider,
-		Client:       client,
+		Client: client,
 	}, nil
 }

@ -33,7 +31,11 @@ func (factory Factory) Observer(provider string) Interface {
 			client: factory.Client,
 		}
 	case provider == "appmesh":
-		return &EnvoyObserver{
+		return &AppMeshObserver{
+			client: factory.Client,
+		}
+	case provider == "crossover":
+		return &CrossoverObserver{
 			client: factory.Client,
 		}
 	case provider == "nginx":
@ -48,6 +50,10 @@ func (factory Factory) Observer(provider string) Interface {
 		return &LinkerdObserver{
 			client: factory.Client,
 		}
+	case provider == "crossover:service":
+		return &CrossoverServiceObserver{
+			client: factory.Client,
+		}
 	case provider == "linkerd":
 		return &LinkerdObserver{
 			client: factory.Client,