@spinnaker/kayenta 0.0.0-main-2

package/src/kayenta/stages/kayentaStage/kayentaStage.transformer.ts

@@ -0,0 +1,179 @@
+import { get, last, round } from 'lodash';
+
+import { Application, IExecution, IExecutionStage, ITransformer, OrchestratedItemTransformer } from '@spinnaker/core';
+
+import { CREATE_SERVER_GROUP, DEPLOY_CANARY_SERVER_GROUPS, KAYENTA_CANARY, RUN_CANARY, WAIT } from './stageTypes';
+
+const stageTypesToAlwaysShow = [KAYENTA_CANARY, CREATE_SERVER_GROUP];
+
+export class KayentaStageTransformer implements ITransformer {
+  public transform(_application: Application, execution: IExecution): void {
+    const kayentaStages = execution.stages.filter(({ type }) => type === KAYENTA_CANARY);
+    if (!kayentaStages.length) {
+      return;
+    }
+
+    let stagesToRenderAsTasks: IExecutionStage[] = [];
+
+    execution.stages.forEach((stage) => {
+      if (stage.type === KAYENTA_CANARY) {
+        OrchestratedItemTransformer.defineProperties(stage);
+
+        const intervalStageId: string = stage.context.intervalStageId;
+        const syntheticCanaryStages = intervalStageId
+          ? execution.stages.filter(
+              ({ parentStageId, type }) =>
+                parentStageId && parentStageId === intervalStageId && [WAIT, RUN_CANARY].includes(type),
+            )
+          : [];
+
+        stagesToRenderAsTasks = stagesToRenderAsTasks.concat(syntheticCanaryStages);
+
+        const runCanaryStages = syntheticCanaryStages.filter((s) => s.type === RUN_CANARY);
+        syntheticCanaryStages.forEach((syntheticStage) => OrchestratedItemTransformer.defineProperties(syntheticStage));
+        this.calculateRunCanaryResults(runCanaryStages);
+        this.calculateKayentaCanaryResults(stage, syntheticCanaryStages);
+
+        stage.exceptions = [];
+        this.addExceptions([stage, ...syntheticCanaryStages], stage.exceptions);
+
+        // For now, a 'kayentaCanary' stage should only have an 'aggregateCanaryResults' task, which should definitely go last.
+        stage.tasks = [...syntheticCanaryStages, ...stage.tasks];
+      } else if (stage.type === CREATE_SERVER_GROUP && this.isDescendantOf(stage, kayentaStages, execution)) {
+        OrchestratedItemTransformer.defineProperties(stage);
+        const parentKayentaStageId = this.isDescendantOf(stage, kayentaStages, execution);
+        const locations = stage.context['deploy.server.groups'] && Object.keys(stage.context['deploy.server.groups']);
+        stage.name = `Deploy ${stage.context.freeFormDetails}${locations ? ' in ' + locations.join(', ') : ''}`;
+        stage.parentStageId = parentKayentaStageId;
+      }
+    });
+
+    const kayentaStageIds = kayentaStages.map(({ id }) => id);
+    const deployCanaryServerGroupsStages = execution.stages.filter(
+      ({ parentStageId, type }) => kayentaStageIds.includes(parentStageId) && type === DEPLOY_CANARY_SERVER_GROUPS,
+    );
+
+    deployCanaryServerGroupsStages.forEach((deployCanaryStage) => {
+      const parentKayentaStage = kayentaStages.find(({ id }) => deployCanaryStage.parentStageId === id);
+      if (parentKayentaStage && (deployCanaryStage.outputs.deployedServerGroups || []).length) {
+        const [{ controlScope, experimentScope }] = deployCanaryStage.outputs.deployedServerGroups;
+        parentKayentaStage.outputs = { ...parentKayentaStage.outputs, controlScope, experimentScope };
+      }
+    });
+    execution.stages = execution.stages.filter(
+      (stage) =>
+        !stagesToRenderAsTasks.includes(stage) &&
+        (!this.isDescendantOf(stage, kayentaStages, execution) ||
+          stageTypesToAlwaysShow.includes(stage.type) ||
+          stage.status !== 'SUCCEEDED'),
+    );
+  }
+
+  private isDescendantOf(child: IExecutionStage, ancestors: IExecutionStage[], execution: IExecution) {
+    const ancestorIds = ancestors.map(({ id }) => id);
+    let node = child;
+    while (node && node.parentStageId) {
+      const parentNode = execution.stages.find(({ id }) => node.parentStageId === id);
+      if (parentNode && ancestorIds.includes(parentNode.id)) {
+        return parentNode.id;
+      } else {
+        node = parentNode;
+      }
+    }
+
+    return null;
+  }
+
+  // Massages each runCanary stage into what the `canaryScore` component expects.
+  private calculateRunCanaryResults(runCanaryStages: IExecutionStage[]): void {
+    runCanaryStages.forEach((run) => {
+      if (typeof run.getValueFor('canaryScore') === 'number') {
+        if (run.status === 'SUCCEEDED') {
+          if (run.context.canaryScore >= run.context.scoreThresholds.pass) {
+            run.result = 'success';
+          }
+        } else {
+          run.health = 'unhealthy';
+        }
+
+        run.context.canaryScore = round(run.context.canaryScore, 2);
+      }
+    });
+  }
+
+  // Massages the kayentaCanary stage results into what the `canaryScore` component expects.
+  private calculateKayentaCanaryResults(kayentaStage: IExecutionStage, runCanaryStages: IExecutionStage[]): void {
+    if (!kayentaStage.isRunning) {
+      if (kayentaStage.getValueFor('canaryScores')) {
+        // If we made it through the final scheduled canary run, this should
+        // be the same as the value returned from `getLastCanaryRunScore`,
+        // but this is also how Orca determines the overall score.
+        kayentaStage.context.overallScore = last(kayentaStage.getValueFor('canaryScores'));
+      } else {
+        kayentaStage.context.overallScore = this.getLastCanaryRunScore(runCanaryStages);
+      }
+      kayentaStage.context.overallScore = round(kayentaStage.context.overallScore, 2);
+
+      // Sometimes when the very first runCanary stage fails due to a low score
+      // it never adds its canaryScoreMessage to the kayenta stage.
+      if (!kayentaStage.context.canaryScoreMessage) {
+        kayentaStage.context.canaryScoreMessage = this.getLastCanaryScoreMessage(runCanaryStages);
+      }
+
+      if (!kayentaStage.isCanceled) {
+        const overallScore = get(kayentaStage, 'context.overallScore', null);
+        const scoreThreshold = get(kayentaStage, 'context.canaryConfig.scoreThresholds.marginal', null);
+        if (kayentaStage.status === 'SUCCEEDED' || (overallScore && overallScore > scoreThreshold)) {
+          kayentaStage.context.overallResult = 'success';
+        } else {
+          kayentaStage.context.overallHealth = 'unhealthy';
+        }
+      }
+    }
+  }
+
+  private getLastCanaryRunScore(runCanaryStages: IExecutionStage[] = []): number {
+    const canaryRunScores = runCanaryStages
+      .filter((s) => typeof s.getValueFor('canaryScore') === 'number')
+      .map((s) => s.getValueFor('canaryScore'));
+    return last(canaryRunScores);
+  }
+
+  private getLastCanaryScoreMessage(runCanaryStages: IExecutionStage[] = []): number {
+    const canaryRunMessages = runCanaryStages
+      .filter((s) => s.getValueFor('canaryScoreMessage'))
+      .map((s) => s.getValueFor('canaryScoreMessage'));
+    return last(canaryRunMessages);
+  }
+
+  private addExceptions(stages: IExecutionStage[], exceptions: string[]): void {
+    stages.forEach((stage) => {
+      if (this.getException(stage)) {
+        exceptions.push(this.getException(stage));
+      }
+      const overallScore = get(stage, 'context.overallScore', null);
+      const scoreThreshold = get(stage, 'context.canaryConfig.scoreThresholds.marginal', null);
+      const message = get(stage, 'context.canaryScoreMessage', null);
+      if (overallScore && message && overallScore <= scoreThreshold) {
+        exceptions.push(message);
+      }
+    });
+  }
+
+  private getException(stage: IExecutionStage): string {
+    if (stage && stage.isFailed) {
+      if (
+        stage.context &&
+        stage.context.exception &&
+        stage.context.exception.details &&
+        stage.context.exception.details.responseBody
+      ) {
+        return stage.context.exception.details.responseBody;
+      } else {
+        return stage.failureMessage;
+      }
+    } else {
+      return null;
+    }
+  }
+}

package/src/kayenta/stages/kayentaStage/kayentaStage.ts

@@ -0,0 +1,221 @@
+import { CanarySettings } from 'kayenta/canary.settings';
+import { IKayentaStage, KayentaAnalysisType } from 'kayenta/domain';
+import { getCanaryConfigById } from 'kayenta/service/canaryConfig.service';
+import { difference, get, has, isEmpty, isString, map, uniq } from 'lodash';
+
+import { IPipeline } from '@spinnaker/core';
+
+import { CanaryExecutionLabel } from './CanaryExecutionLabel';
+
+const isExpression = (value: string) => isString(value) && value.includes('${');
+
+const emailPattern = /^(.+)@(.+).([A-Za-z]{2,6})/;
+const isValidEmail = (email: string) => isExpression(email) || email.match(emailPattern);
+
+const utcInstantPattern = /^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]+)?(Z)?$/;
+const isValidUtcInstant = (timestamp: string) =>
+  isExpression(timestamp) || (isString(timestamp) && timestamp.match(utcInstantPattern));
+
+const requiredForAnalysisTypes = (
+  analysisTypes: KayentaAnalysisType[] = [],
+  fieldName: string,
+  fieldLabel?: string,
+): ((p: IPipeline, s: IKayentaStage) => string) => {
+  return (_pipeline: IPipeline, stage: IKayentaStage): string => {
+    if (analysisTypes.includes(stage.analysisType)) {
+      if (!has(stage, fieldName) || get(stage, fieldName) === '') {
+        return `<strong>${fieldLabel || fieldName}</strong> is a required field for Kayenta Canary stages.`;
+      }
+    }
+    return null;
+  };
+};
+
+const allScopesMustBeConfigured = (_pipeline: IPipeline, stage: IKayentaStage): PromiseLike<string> => {
+  return getCanaryConfigById(get(stage, 'canaryConfig.canaryConfigId')).then((configDetails) => {
+    let definedScopeNames = uniq(map(configDetails.metrics, (metric) => metric.scopeName || 'default'));
+    definedScopeNames = !isEmpty(definedScopeNames) ? definedScopeNames : ['default'];
+
+    const configureScopedNames: string[] = map(get(stage, 'canaryConfig.scopes'), 'scopeName');
+    const missingScopeNames = difference(definedScopeNames, configureScopedNames);
+
+    if (missingScopeNames.length > 1) {
+      return `Scopes <strong>${missingScopeNames.join()}</strong> are defined but not configured.`;
+    } else if (missingScopeNames.length === 1) {
+      return `Scope <strong>${missingScopeNames[0]}</strong> is defined but not configured.`;
+    } else {
+      return null;
+    }
+  });
+};
+
+const allConfiguredScopesMustBeDefined = (_pipeline: IPipeline, stage: IKayentaStage): PromiseLike<string> => {
+  return getCanaryConfigById(get(stage, 'canaryConfig.canaryConfigId')).then((configDetails) => {
+    let definedScopeNames = uniq(map(configDetails.metrics, (metric) => metric.scopeName || 'default'));
+    definedScopeNames = !isEmpty(definedScopeNames) ? definedScopeNames : ['default'];
+
+    const configureScopedNames: string[] = map(get(stage, 'canaryConfig.scopes'), 'scopeName');
+    const missingScopeNames = difference(configureScopedNames, definedScopeNames);
+
+    if (missingScopeNames.length > 1) {
+      return `Scopes <strong>${missingScopeNames.join()}</strong> are configured but are not defined in the canary configuration.`;
+    } else if (missingScopeNames.length === 1) {
+      return `Scope <strong>${missingScopeNames[0]}</strong> is configured but is not defined in the canary configuration.`;
+    } else {
+      return null;
+    }
+  });
+};
+
+export const kayentaCanaryStage = {
+  label: CanarySettings.stageName || 'Canary Analysis',
+  description: CanarySettings.stageDescription || 'Runs a canary task',
+  key: 'kayentaCanary',
+  templateUrl: require('./kayentaStage.html'),
+  controller: 'KayentaCanaryStageCtrl',
+  controllerAs: 'kayentaCanaryStageCtrl',
+  executionDetailsUrl: require('./kayentaStageExecutionDetails.html'),
+  executionLabelComponent: CanaryExecutionLabel,
+  validators: [
+    { type: 'requiredField', fieldName: 'canaryConfig.canaryConfigId', fieldLabel: 'Config Name' },
+    { type: 'requiredField', fieldName: 'canaryConfig.metricsAccountName', fieldLabel: 'Metrics Account' },
+    { type: 'requiredField', fieldName: 'canaryConfig.storageAccountName', fieldLabel: 'Storage Account' },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.RealTimeAutomatic],
+        'deployments.serverGroupPairs[0].control',
+        'Baseline & Canary Server Groups',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.RealTimeAutomatic],
+        'deployments.baseline.cluster',
+        'Baseline Cluster',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.RealTimeAutomatic],
+        'deployments.baseline.account',
+        'Baseline Account',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.RealTime, KayentaAnalysisType.Retrospective],
+        'canaryConfig.scopes[0].controlScope',
+        'Baseline Scope',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.RealTime, KayentaAnalysisType.Retrospective],
+        'canaryConfig.scopes[0].experimentScope',
+        'Canary Scope',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.RealTime, KayentaAnalysisType.RealTimeAutomatic],
+        'canaryConfig.lifetimeDuration',
+        'Lifetime',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.Retrospective],
+        'canaryConfig.scopes[0].startTimeIso',
+        'Start Time',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: requiredForAnalysisTypes(
+        [KayentaAnalysisType.Retrospective],
+        'canaryConfig.scopes[0].endTimeIso',
+        'End Time',
+      ),
+    },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, stage: IKayentaStage) => {
+        if (
+          !has(stage, 'canaryConfig.canaryConfigId') ||
+          stage.analysisType === KayentaAnalysisType.RealTimeAutomatic
+        ) {
+          return null;
+        }
+
+        return getCanaryConfigById(get(stage, 'canaryConfig.canaryConfigId')).then((configDetails) => {
+          if (
+            get(configDetails, 'metrics[0].query.type') === 'atlas' &&
+            !get(stage, 'canaryConfig.scopes[0].extendedScopeParams.type')
+          ) {
+            return 'Scope Type is required';
+          } else {
+            return null;
+          }
+        });
+      },
+    },
+    {
+      type: 'custom',
+      validate: allScopesMustBeConfigured,
+    },
+    {
+      type: 'custom',
+      validate: allConfiguredScopesMustBeDefined,
+    },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, { canaryConfig }: IKayentaStage) => {
+        if (!CanarySettings.legacySiteLocalFieldsEnabled) {
+          return null;
+        }
+        const notificationEmail = get(canaryConfig, 'siteLocal.notificationEmail');
+        if (!notificationEmail) {
+          return null;
+        }
+        const emails = Array.isArray(notificationEmail) ? notificationEmail : [notificationEmail];
+        const invalidEmail = emails.find((email) => !isValidEmail(email));
+        return invalidEmail ? `Invalid <strong>Notification Email</strong> (${invalidEmail})` : null;
+      },
+    },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, stage: IKayentaStage) => {
+        const startTime: string = get(stage, 'canaryConfig.scopes[0].startTimeIso');
+        if (
+          stage.analysisType === KayentaAnalysisType.Retrospective &&
+          !isEmpty(startTime) &&
+          !isValidUtcInstant(startTime)
+        ) {
+          return '<strong>Start Time</strong> must be formatted as a UTC instant using ISO-8601 instant format (e.g., 2018-07-12T20:28:29Z).';
+        }
+        return null;
+      },
+    },
+    {
+      type: 'custom',
+      validate: (_pipeline: IPipeline, stage: IKayentaStage) => {
+        const endTime: string = get(stage, 'canaryConfig.scopes[0].endTimeIso');
+        if (
+          stage.analysisType === KayentaAnalysisType.Retrospective &&
+          !isEmpty(endTime) &&
+          !isValidUtcInstant(endTime)
+        ) {
+          return '<strong>End Time</strong> must be formatted as a UTC instant using ISO-8601 instant format (e.g., 2018-07-12T20:28:29Z).';
+        }
+        return null;
+      },
+    },
+  ],
+};

package/src/kayenta/stages/kayentaStage/kayentaStageConfigSection.component.ts

@@ -0,0 +1,21 @@
+import { IComponentOptions, module } from 'angular';
+
+const kayentaStageConfigSection: IComponentOptions = {
+  transclude: {
+    sectionHeader: '?sectionHeader',
+  },
+  bindings: { title: '@' },
+  template: `
+    <section>
+      <ul class="list-inline">
+        <li><h5>{{ $ctrl.title }}</h5></li>
+        <li><span ng-transclude="sectionHeader"></span></li>
+      </ul>
+      <div class="horizontal-rule"></div>
+      <ng-transclude></ng-transclude>
+    </section>
+  `,
+};
+
+export const KAYENTA_STAGE_CONFIG_SECTION = 'spinnaker.kayenta.stageConfigSection';
+module(KAYENTA_STAGE_CONFIG_SECTION, []).component('kayentaStageConfigSection', kayentaStageConfigSection);

package/src/kayenta/stages/kayentaStage/kayentaStageExecutionDetails.controller.ts

@@ -0,0 +1,88 @@
+import { StateParams } from '@uirouter/angularjs';
+import { IScope, module } from 'angular';
+import { ICanaryConfigSummary, KayentaAnalysisType } from 'kayenta/domain';
+
+import { ExecutionDetailsSectionService, IExecutionStage } from '@spinnaker/core';
+
+import { CANARY_RUN_SUMMARIES_COMPONENT } from './canaryRunSummaries.component';
+import { KAYENTA_CANARY, RUN_CANARY } from './stageTypes';
+
+import './kayentaStageExecutionDetails.less';
+
+class KayentaStageExecutionDetailsController {
+  public static $inject = ['$scope', '$stateParams', 'executionDetailsSectionService'];
+
+  public canaryRuns: IExecutionStage[];
+  public canaryConfigName: string;
+  public firstScopeName: string;
+  public resolvedControl: string;
+  public resolvedExperiment: string;
+
+  constructor(
+    public $scope: IScope,
+    private $stateParams: StateParams,
+    private executionDetailsSectionService: ExecutionDetailsSectionService,
+  ) {
+    'ngInject';
+    this.$scope.configSections = ['canarySummary', 'canaryConfig', 'taskStatus'];
+    this.$scope.$on('$stateChangeSuccess', () => this.initialize());
+  }
+
+  public $onInit(): void {
+    this.initialize();
+  }
+
+  private initialize(): void {
+    this.executionDetailsSectionService.synchronizeSection(this.$scope.configSections, () => this.initialized());
+  }
+
+  private initialized(): void {
+    this.$scope.detailsSection = this.$stateParams.details;
+    this.$scope.application.ready().then(() => {
+      if (this.$scope.stage.type !== KAYENTA_CANARY) {
+        return;
+      }
+      const canaryConfigSummary = this.$scope.application
+        .getDataSource('canaryConfigs')
+        .data.find(
+          (config: ICanaryConfigSummary) => config.id === this.$scope.stage.context.canaryConfig.canaryConfigId,
+        );
+      if (canaryConfigSummary) {
+        this.canaryConfigName = canaryConfigSummary.name;
+      }
+    });
+    this.setCanaryRuns();
+    this.resolveFirstScopeName();
+    this.resolveControlAndExperimentNames();
+    this.$scope.$watchCollection('stage.tasks', () => this.setCanaryRuns());
+  }
+
+  private setCanaryRuns(): void {
+    // The kayentaStageTransformer pushes related 'runCanary' and 'wait' stages
+    // into the 'kayentaCanary' tasks list.
+    this.canaryRuns = this.$scope.stage.tasks.filter((t: IExecutionStage) => t.type === RUN_CANARY);
+  }
+
+  private resolveFirstScopeName(): void {
+    this.firstScopeName = this.$scope.stage.context.canaryConfig.scopes[0].scopeName;
+  }
+
+  private resolveControlAndExperimentNames(): void {
+    if (this.$scope.stage.context.analysisType === KayentaAnalysisType.RealTimeAutomatic) {
+      this.resolvedControl = this.$scope.stage.outputs.controlScope;
+      this.resolvedExperiment = this.$scope.stage.outputs.experimentScope;
+    } else {
+      this.resolvedControl = this.canaryRuns.length
+        ? this.canaryRuns[0].context.scopes[this.firstScopeName].controlScope.scope
+        : this.$scope.stage.context.canaryConfig.scopes[0].controlScope;
+      this.resolvedExperiment = this.canaryRuns.length
+        ? this.canaryRuns[0].context.scopes[this.firstScopeName].experimentScope.scope
+        : this.$scope.stage.context.canaryConfig.scopes[0].experimentScope;
+    }
+  }
+}
+
+export const KAYENTA_STAGE_EXECUTION_DETAILS_CONTROLLER = 'spinnaker.kayenta.kayentaStageExecutionDetails.controller';
+module(KAYENTA_STAGE_EXECUTION_DETAILS_CONTROLLER, [CANARY_RUN_SUMMARIES_COMPONENT])
+  .controller('kayentaStageExecutionDetailsCtrl', KayentaStageExecutionDetailsController)
+  .filter('dateToMillis', () => Date.parse);

package/src/kayenta/stages/kayentaStage/kayentaStageExecutionDetails.html

@@ -0,0 +1,114 @@
+<div class="canary-details" ng-controller="kayentaStageExecutionDetailsCtrl as kayentaStageDetailsCtrl">
+  <execution-details-section-nav sections="configSections"></execution-details-section-nav>
+  <div class="step-section-details" ng-if="detailsSection === 'canarySummary'">
+    <div class="row">
+      <div class="col-md-2 canary-summary">
+        <div class="score score-large">
+          <kayenta-canary-score
+            score="stage.context.overallScore"
+            health="stage.context.overallHealth"
+            result="stage.context.overallResult"
+          ></kayenta-canary-score>
+        </div>
+      </div>
+    </div>
+
+    <div class="row">
+      <div class="col-md-12 horizontal">
+        <canary-run-summaries
+          class="horizontal flex-1"
+          canary-runs="kayentaStageDetailsCtrl.canaryRuns"
+          first-scope-name="kayentaStageDetailsCtrl.firstScopeName"
+        ></canary-run-summaries>
+      </div>
+    </div>
+
+    <stage-failure-message
+      stage="stage"
+      is-failed="stage.exceptions.length > 0"
+      messages="stage.exceptions"
+    ></stage-failure-message>
+  </div>
+
+  <div class="step-section-details" ng-if="detailsSection === 'canaryConfig'">
+    <div class="row">
+      <div class="col-md-12 canary-config-section">
+        <h5>Scope</h5>
+        <div class="horizontal-rule"></div>
+        <div class="row">
+          <div class="col-md-4 sm-label-right compact">Baseline</div>
+          <div class="col-md-8" style="word-wrap: break-word">{{ kayentaStageDetailsCtrl.resolvedControl }}</div>
+        </div>
+        <div class="row">
+          <div class="col-md-4 sm-label-right compact">Canary</div>
+          <div class="col-md-8" style="word-wrap: break-word">{{ kayentaStageDetailsCtrl.resolvedExperiment }}</div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.scopes[0].step">
+          <div class="col-md-4 sm-label-right compact">Step</div>
+          <div class="col-md-8" style="word-wrap: break-word">{{stage.context.canaryConfig.scopes[0].step}}</div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.scopes[0].startTimeIso">
+          <div class="col-md-4 sm-label-right compact">Start Time</div>
+          <div class="col-md-8" style="word-wrap: break-word">
+            {{ stage.context.canaryConfig.scopes[0].startTimeIso | dateToMillis | timestamp}}
+          </div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.scopes[0].endTimeIso">
+          <div class="col-md-4 sm-label-right compact">End Time</div>
+          <div class="col-md-8" style="word-wrap: break-word">
+            {{stage.context.canaryConfig.scopes[0].endTimeIso | dateToMillis | timestamp}}
+          </div>
+        </div>
+      </div>
+      <div class="col-md-12 canary-config-section">
+        <h5>Analysis Config</h5>
+        <div class="horizontal-rule"></div>
+        <div class="row">
+          <div class="col-md-4 sm-label-right compact">Config Name</div>
+          <div class="col-md-8" style="word-wrap: break-word">
+            <a
+              href
+              ui-sref="home.applications.application.canary.canaryConfig.configDetail({id: stage.context.canaryConfig.canaryConfigId})"
+            >
+              {{kayentaStageDetailsCtrl.canaryConfigName}}
+            </a>
+          </div>
+        </div>
+        <div class="row">
+          <div class="col-md-4 sm-label-right compact">Analysis Type</div>
+          <div class="col-md-8" style="word-wrap: break-word">{{stage.context.analysisType | robotToHuman}}</div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.lifetimeHours">
+          <div class="col-md-4 sm-label-right compact">Duration</div>
+          <div class="col-md-6">{{stage.context.canaryConfig.lifetimeHours}} hours</div>
+        </div>
+        <div class="row">
+          <div class="col-md-4 sm-label-right compact">Pass</div>
+          <div class="col-md-6">{{stage.context.canaryConfig.scoreThresholds.pass}}</div>
+        </div>
+        <div class="row">
+          <div class="col-md-4 sm-label-right compact">Marginal</div>
+          <div class="col-md-6">{{stage.context.canaryConfig.scoreThresholds.marginal}}</div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.beginCanaryAnalysisAfterMins">
+          <div class="col-md-4 sm-label-right compact">Warmup Period</div>
+          <div class="col-md-6">{{stage.context.canaryConfig.beginCanaryAnalysisAfterMins}} minutes</div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.canaryAnalysisIntervalMins">
+          <div class="col-md-4 sm-label-right compact">Interval</div>
+          <div class="col-md-6">{{stage.context.canaryConfig.canaryAnalysisIntervalMins}} minutes</div>
+        </div>
+        <div class="row" ng-if="stage.context.canaryConfig.baselineAnalysisOffsetInMins">
+          <div class="col-md-4 sm-label-right compact">Baseline Offset</div>
+          <div class="col-md-6">{{stage.context.canaryConfig.baselineAnalysisOffsetInMins}} minutes</div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <div class="step-section-details" ng-if="detailsSection === 'taskStatus'">
+    <div class="row">
+      <execution-step-details item="stage"></execution-step-details>
+    </div>
+  </div>
+</div>

package/src/kayenta/stages/kayentaStage/kayentaStageExecutionDetails.less

@@ -0,0 +1,6 @@
+.canary-config-section {
+  .col-md-6,
+  .col-md-8 {
+    margin-top: 5px;
+  }
+}

package/src/kayenta/stages/kayentaStage/stageTypes.ts

@@ -0,0 +1,5 @@
+export const KAYENTA_CANARY = 'kayentaCanary';
+export const RUN_CANARY = 'runCanary';
+export const WAIT = 'wait';
+export const CREATE_SERVER_GROUP = 'createServerGroup';
+export const DEPLOY_CANARY_SERVER_GROUPS = 'deployCanaryServerGroups';