diff --git a/analysis/analysis_test.go b/analysis/analysis_test.go
index ed12da2dca..71949b2084 100644
--- a/analysis/analysis_test.go
+++ b/analysis/analysis_test.go
@@ -1500,7 +1500,7 @@ func TestAssessRunStatusErrorMessageAnalysisPhaseFail(t *testing.T) {
 
 func TestAssessRunStatusErrorMessageAnalysisPhaseFailInDryRunMode(t *testing.T) {
 	status, message, dryRunSummary := StartAssessRunStatusErrorMessageAnalysisPhaseFail(t, true)
-	assert.Equal(t, v1alpha1.AnalysisPhaseSuccessful, status)
+	assert.Equal(t, v1alpha1.AnalysisPhaseRunning, status)
 	assert.Equal(t, "", message)
 	expectedDryRunSummary := v1alpha1.RunSummary{
 		Count:        2,
@@ -1545,7 +1545,7 @@ func TestAssessRunStatusErrorMessageFromProvider(t *testing.T) {
 func TestAssessRunStatusErrorMessageFromProviderInDryRunMode(t *testing.T) {
 	providerMessage := "Provider Error"
 	status, message, dryRunSummary := StartAssessRunStatusErrorMessageFromProvider(t, providerMessage, true)
-	assert.Equal(t, v1alpha1.AnalysisPhaseSuccessful, status)
+	assert.Equal(t, v1alpha1.AnalysisPhaseRunning, status)
 	assert.Equal(t, "", message)
 	expectedDryRunSummary := v1alpha1.RunSummary{
 		Count:        2,
@@ -1587,7 +1587,7 @@ func TestAssessRunStatusMultipleFailures(t *testing.T) {
 
 func TestAssessRunStatusMultipleFailuresInDryRunMode(t *testing.T) {
 	status, message, dryRunSummary := StartAssessRunStatusMultipleFailures(t, true)
-	assert.Equal(t, v1alpha1.AnalysisPhaseSuccessful, status)
+	assert.Equal(t, v1alpha1.AnalysisPhaseRunning, status)
 	assert.Equal(t, "", message)
 	expectedDryRunSummary := v1alpha1.RunSummary{
 		Count:        2,
@@ -1732,7 +1732,7 @@ func TestAssessRunStatusWorstMessageInReconcileAnalysisRun(t *testing.T) {
 
 func TestAssessRunStatusWorstMessageInReconcileAnalysisRunInDryRunMode(t *testing.T) {
 	newRun := StartAssessRunStatusWorstMessageInReconcileAnalysisRun(t, true)
-	assert.Equal(t, v1alpha1.AnalysisPhaseSuccessful, newRun.Status.Phase)
+	assert.Equal(t, v1alpha1.AnalysisPhaseRunning, newRun.Status.Phase)
 	assert.Equal(t, "", newRun.Status.Message)
 	expectedDryRunSummary := v1alpha1.RunSummary{
 		Count:        2,
diff --git a/examples/traffic-routing/istio-mirror.yaml b/examples/traffic-routing/istio-mirror.yaml
new file mode 100644
index 0000000000..d56c36add4
--- /dev/null
+++ b/examples/traffic-routing/istio-mirror.yaml
@@ -0,0 +1,117 @@
+## This examples sets up istio mirroring if running locally using docker for destkop you can add
+## istio-host-split.com to your /etc/hosts and point it to 127.0.0.1 to view demo.
+apiVersion: v1
+kind: Service
+metadata:
+  name: istio-host-split-canary
+spec:
+  ports:
+    - port: 80
+      targetPort: http
+      protocol: TCP
+      name: http
+  selector:
+    app: istio-host-split
+
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: istio-host-split-stable
+spec:
+  ports:
+    - port: 80
+      targetPort: http
+      protocol: TCP
+      name: http
+  selector:
+    app: istio-host-split
+
+---
+apiVersion: networking.istio.io/v1alpha3
+kind: VirtualService
+metadata:
+  name: istio-host-split-vsvc
+spec:
+  hosts:
+    - istio-host-split.com
+  gateways:
+    - istio-host-split-gateway
+  http:
+    - name: primary
+      route:
+        - destination:
+            host: istio-host-split-stable
+          weight: 100
+        - destination:
+            host: istio-host-split-canary
+          weight: 0
+
+---
+apiVersion: argoproj.io/v1alpha1
+kind: Rollout
+metadata:
+  name: istio-host-split
+spec:
+  replicas: 4
+  strategy:
+    canary:
+      canaryService: istio-host-split-canary
+      stableService: istio-host-split-stable
+      trafficRouting:
+        managedRoutes:
+          - name: mirror-route
+        istio:
+          virtualService:
+            name: istio-host-split-vsvc
+            routes:
+              - primary
+      steps:
+        - setCanaryScale:
+            weight: 50
+        - setMirrorRoute:
+            name: mirror-route
+            percentage: 50
+            match:
+              - method:
+                  exact: POST
+                path:
+                  prefix: /color
+        - pause: {}
+  selector:
+    matchLabels:
+      app: istio-host-split
+  template:
+    metadata:
+      labels:
+        app: istio-host-split
+    spec:
+      containers:
+        - name: istio-host-split
+          image: argoproj/rollouts-demo:green
+          ports:
+            - name: http
+              containerPort: 8080
+              protocol: TCP
+          resources:
+            requests:
+              memory: 16Mi
+              cpu: 5m
+
+---
+
+apiVersion: networking.istio.io/v1alpha3
+kind: Gateway
+metadata:
+  name: istio-host-split-gateway
+spec:
+  selector:
+    istio: ingressgateway # use istio default controller
+  servers:
+    - port:
+        number: 80
+        name: http
+        protocol: HTTP
+      hosts:
+        - "istio-host-split.com"
+
diff --git a/ingress/ingress_test.go b/ingress/ingress_test.go
index 358c62927c..f2d1a35e19 100644
--- a/ingress/ingress_test.go
+++ b/ingress/ingress_test.go
@@ -245,6 +245,77 @@ func TestSyncIngressReferencedByRollout(t *testing.T) {
 	assert.Equal(t, 1, enqueuedObjects["default/rollout"])
 }
 
+func TestSkipIngressWithNoClass(t *testing.T) {
+	ing := newNginxIngressWithAnnotation("test-stable-ingress", 80, "stable-service")
+	ing.Annotations = nil
+	rollout := &v1alpha1.Rollout{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "rollout",
+			Namespace: metav1.NamespaceDefault,
+		},
+		Spec: v1alpha1.RolloutSpec{
+			Strategy: v1alpha1.RolloutStrategy{
+				Canary: &v1alpha1.CanaryStrategy{
+					StableService: "stable-service",
+					CanaryService: "canary-service",
+					TrafficRouting: &v1alpha1.RolloutTrafficRouting{
+						Nginx: &v1alpha1.NginxTrafficRouting{
+							StableIngress: "test-stable-ingress",
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ctrl, kubeclient, enqueuedObjects := newFakeIngressController(t, ing, rollout)
+
+	err := ctrl.syncIngress("default/test-stable-ingress")
+	assert.NoError(t, err)
+	actions := kubeclient.Actions()
+	assert.Len(t, actions, 0)
+	assert.Len(t, enqueuedObjects, 0)
+}
+
+func TestSkipIngressWithNoClassMultiIngress(t *testing.T) {
+	ings := []*extensionsv1beta1.Ingress{
+		newNginxIngressWithAnnotation("test-stable-ingress", 80, "stable-service"),
+		newNginxIngressWithAnnotation("test-stable-ingress-additional", 80, "stable-service"),
+	}
+	for _, i := range ings {
+		i.Annotations = nil
+	}
+
+	rollout := &v1alpha1.Rollout{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "rollout",
+			Namespace: metav1.NamespaceDefault,
+		},
+		Spec: v1alpha1.RolloutSpec{
+			Strategy: v1alpha1.RolloutStrategy{
+				Canary: &v1alpha1.CanaryStrategy{
+					StableService: "stable-service",
+					CanaryService: "canary-service",
+					TrafficRouting: &v1alpha1.RolloutTrafficRouting{
+						Nginx: &v1alpha1.NginxTrafficRouting{
+							StableIngress:             "test-stable-ingress",
+							AdditionalStableIngresses: []string{"test-stable-ingress-additional"},
+						},
+					},
+				},
+			},
+		},
+	}
+
+	ctrl, kubeclient, enqueuedObjects := newFakeIngressControllerMultiIngress(t, ings, rollout)
+
+	err := ctrl.syncIngress("default/test-stable-ingress")
+	assert.NoError(t, err)
+	actions := kubeclient.Actions()
+	assert.Len(t, actions, 0)
+	assert.Len(t, enqueuedObjects, 0)
+}
+
 func TestSyncIngressReferencedByRolloutMultiIngress(t *testing.T) {
 	ings := []*extensionsv1beta1.Ingress{
 		newNginxIngress("test-stable-ingress", 80, "stable-service"),
diff --git a/rollout/trafficrouting/nginx/nginx_test.go b/rollout/trafficrouting/nginx/nginx_test.go
index d0037574c9..7aca48c9d5 100644
--- a/rollout/trafficrouting/nginx/nginx_test.go
+++ b/rollout/trafficrouting/nginx/nginx_test.go
@@ -1194,6 +1194,45 @@ func TestReconcileCanaryCreateErrorAlreadyExistsPatch(t *testing.T) {
 	}
 }
 
+func TestSetHeaderRoute(t *testing.T) {
+	r := Reconciler{
+		cfg: ReconcilerConfig{
+			Rollout: fakeRollout("stable-service", "canary-service", "stable-ingress"),
+		},
+	}
+	err := r.SetHeaderRoute(&v1alpha1.SetHeaderRoute{
+		Name: "set-header",
+		Match: []v1alpha1.HeaderRoutingMatch{{
+			HeaderName: "header-name",
+			HeaderValue: &v1alpha1.StringMatch{
+				Exact: "value",
+			},
+		}},
+	})
+	assert.Nil(t, err)
+
+	err = r.RemoveManagedRoutes()
+	assert.Nil(t, err)
+}
+
+func TestSetMirrorRoute(t *testing.T) {
+	r := Reconciler{
+		cfg: ReconcilerConfig{
+			Rollout: fakeRollout("stable-service", "canary-service", "stable-ingress"),
+		},
+	}
+	err := r.SetMirrorRoute(&v1alpha1.SetMirrorRoute{
+		Name: "mirror-route",
+		Match: []v1alpha1.RouteMatch{{
+			Method: &v1alpha1.StringMatch{Exact: "GET"},
+		}},
+	})
+	assert.Nil(t, err)
+
+	err = r.RemoveManagedRoutes()
+	assert.Nil(t, err)
+}
+
 func TestReconcileCanaryCreateErrorAlreadyExistsPatchMultiIngress(t *testing.T) {
 	rollout := fakeRolloutWithMultiIngress("stable-service", "canary-service", "stable-ingress", "additional-stable-ingress")
 	stableIngress := extensionsIngress("stable-ingress", 80, "stable-service")
diff --git a/server/server.go b/server/server.go
index a69d90d5f0..787ab5a100 100644
--- a/server/server.go
+++ b/server/server.go
@@ -3,6 +3,7 @@ package server
 import (
 	"context"
 	"fmt"
+	"io/fs"
 	"net"
 	"net/http"
 	"strings"
@@ -110,6 +111,36 @@ func (s *ArgoRolloutsServer) newHTTPServer(ctx context.Context, port int) *http.
 	return &httpS
 }
 
+func (s *ArgoRolloutsServer) readIndexHtml() ([]byte, error) {
+	file, err := static.Open("static/index.html")
+	if err != nil {
+		log.Errorf("Failed to open file %s: %v", "static/index.html", err)
+		return nil, err
+	}
+	defer func() {
+		if file != nil {
+			if err := file.Close(); err != nil {
+				log.Errorf("Error closing file: %v", err)
+			}
+		}
+	}()
+
+	stat, err := file.Stat()
+	if err != nil {
+		log.Errorf("Failed to stat file or dir %s: %v", "static/index.html", err)
+		return nil, err
+	}
+
+	fileBytes := make([]byte, stat.Size())
+	_, err = file.Read(fileBytes)
+	if err != nil {
+		log.Errorf("Failed to read file %s: %v", "static/index.html", err)
+		return nil, err
+	}
+
+	return withRootPath(fileBytes, s.Options.RootPath), nil
+}
+
 func (s *ArgoRolloutsServer) newGRPCServer() *grpc.Server {
 	grpcS := grpc.NewServer()
 	var rolloutsServer rollout.RolloutServiceServer = NewServer(s.Options)
diff --git a/ui/src/models/rollout/generated/api.ts b/ui/src/models/rollout/generated/api.ts
index 7344e5fb5f..fc6f1d6548 100755
--- a/ui/src/models/rollout/generated/api.ts
+++ b/ui/src/models/rollout/generated/api.ts
@@ -811,6 +811,19 @@ export interface GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1MangedRoute
      */
     name?: string;
 }
+/**
+ * 
+ * @export
+ * @interface GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1MangedRoutes
+ */
+export interface GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1MangedRoutes {
+    /**
+     * 
+     * @type {string}
+     * @memberof GithubComArgoprojArgoRolloutsPkgApisRolloutsV1alpha1MangedRoutes
+     */
+    name?: string;
+}
 /**
  * MeasurementRetention defines the settings for retaining the number of measurements during the analysis.
  * @export
diff --git a/utils/analysis/helpers.go b/utils/analysis/helpers.go
index caedeb472c..4ee47de08f 100644
--- a/utils/analysis/helpers.go
+++ b/utils/analysis/helpers.go
@@ -93,7 +93,9 @@ func IsTerminating(run *v1alpha1.AnalysisRun) bool {
 
 		switch res.Phase {
 		case v1alpha1.AnalysisPhaseFailed, v1alpha1.AnalysisPhaseError, v1alpha1.AnalysisPhaseInconclusive:
-			return true
+			// If this metric is running in the dryRun mode then we don't care about the failures and hence the terminal
+			// decision shouldn't be affected.
+			return !res.DryRun
 		}
 	}
 	return false