Seed Dashboard Sample Data with Labeled Executions

id: dashboard-sample-data-seeder
namespace: company.team
description: |
  Seed a dashboard with meaningful sample executions: plan combinations of
  service and environment labels, fan out child executions carrying those
  labels through a Subflow loop - with a deliberate mix of passing and
  failing runs - then report what was created, so a fresh dashboard shows
  real charts instead of empty states.

triggers:
  - id: seed_on_demand
    type: io.kestra.plugin.core.trigger.Webhook
    description: POST to the keyed webhook URL to seed sample data on demand; the
      flow also runs manually from the UI.
    key: "{{ secret('SEED_WEBHOOK_KEY') }}"

inputs:
  - id: mode
    type: STRING
    defaults: parent
    description: Internal switch. Leave on parent to seed; the Subflow task
      re-invokes this flow as child to create each sample execution.
  - id: services
    type: STRING
    defaults: api,web,worker
    description: Comma-separated service names spread across the sample executions.
  - id: environments
    type: STRING
    defaults: staging,prod
    description: Comma-separated environment names spread across the sample executions.
  - id: samples_per_combination
    type: INT
    defaults: 2
    description: Sample executions per service × environment combination (3 services
      × 2 environments × 2 = 12 by default).
  - id: service
    type: STRING
    defaults: api
    description: Service label for a child sample execution; set by the parent loop.
  - id: environment
    type: STRING
    defaults: staging
    description: Environment label for a child sample execution; set by the parent loop.
  - id: should_fail
    type: BOOL
    defaults: false
    description: When true the child sample fails on purpose so dashboards show a
      state mix; set by the parent loop.
  - id: sleep_seconds
    type: INT
    defaults: 2
    description: Seconds a child sample burns before finishing, so duration charts
      have variety; set by the parent loop.

tasks:
  - id: plan_samples
    type: io.kestra.plugin.scripts.python.Script
    description: Turn the services × environments matrix into a deterministic sample
      list - every fourth run fails on purpose and sleep varies - so both modes
      share one plan and outputs always resolve.
    taskRunner:
      type: io.kestra.plugin.core.runner.Process
    env:
      SERVICES: "{{ inputs.services }}"
      ENVIRONMENTS: "{{ inputs.environments }}"
      SAMPLES_PER_COMBO: "{{ inputs.samples_per_combination }}"
    script: |
      import json
      import os

      services = [s.strip() for s in os.environ["SERVICES"].split(",") if s.strip()]
      environments = [e.strip() for e in os.environ["ENVIRONMENTS"].split(",") if e.strip()]
      per_combo = int(os.environ["SAMPLES_PER_COMBO"])

      items = []
      idx = 0
      for service in services:
          for environment in environments:
              for _ in range(per_combo):
                  items.append({
                      "service": service,
                      "environment": environment,
                      "should_fail": idx % 4 == 3,
                      "sleep_seconds": 2 + idx % 5,
                  })
                  idx += 1

      failures = sum(1 for i in items if i["should_fail"])
      print(f"Planned {len(items)} sample executions ({failures} failing on purpose)")
      print("::" + json.dumps({"outputs": {
          "items": items,
          "total": len(items),
          "failing": failures,
      }}) + "::")

  - id: is_parent
    type: io.kestra.plugin.core.flow.If
    description: Parent mode fans out the samples; child mode (invoked through
      Subflow) produces one labeled sample execution and stops.
    condition: "{{ inputs.mode != 'child' }}"
    then:
      - id: seed_executions
        type: io.kestra.plugin.core.flow.Loop
        description: One sample execution per planned combination, each a child
          execution of this flow carrying its service and environment labels.
        values: "{{ outputs.plan_samples.vars.items }}"
        tasks:
          - id: run_sample
            type: io.kestra.plugin.core.flow.Subflow
            description: Re-invoke this flow in child mode with the sample's labels;
              transmitFailed stays false so the planned failures never fail the
              seeder itself.
            namespace: "{{ flow.namespace }}"
            flowId: "{{ flow.id }}"
            wait: true
            transmitFailed: false
            inputs:
              mode: child
              service: "{{ item.value.service }}"
              environment: "{{ item.value.environment }}"
              should_fail: "{{ item.value.should_fail }}"
              sleep_seconds: "{{ item.value.sleep_seconds }}"
            labels:
              service: "{{ item.value.service }}"
              environment: "{{ item.value.environment }}"
              dashboard_sample: "true"

      - id: report_seeding
        type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
        description: Summarize how many labeled sample executions now exist so the
          dashboard can be opened with expectations set.
        url: "{{ secret('SLACK_WEBHOOK_URL') }}"
        payload: |
          {
            "text": "Dashboard sample data seeded: {{ outputs.plan_samples.vars.total }} executions across services [{{ inputs.services }}] and environments [{{ inputs.environments }}] ({{ outputs.plan_samples.vars.failing }} failing on purpose), labels service/environment/dashboard_sample applied. Open your pipeline dashboard - parent execution {{ execution.id }}."
          }
    else:
      - id: sample_work
        type: io.kestra.plugin.core.debug.Return
        description: Stand-in work for the sample execution; replace with your own
          flow's real tasks when repointing the seeder.
        format: "sample {{ inputs.service }}/{{ inputs.environment }} run {{
          execution.id }}"

      - id: sample_burn_time
        type: io.kestra.plugin.core.flow.Sleep
        description: Burn a few seconds so duration charts show variety between samples.
        duration: "PT{{ inputs.sleep_seconds }}S"

      - id: maybe_fail
        type: io.kestra.plugin.core.flow.If
        description: Fail a deliberate share of samples so state breakdowns on the
          dashboard look realistic.
        condition: "{{ inputs.should_fail }}"
        then:
          - id: mark_sample_failed
            type: io.kestra.plugin.core.execution.Fail
            description: End this sample execution in FAILED on purpose.
            errorMessage: "Planned sample failure for dashboard realism (service {{
              inputs.service }}, environment {{ inputs.environment }})."
        else:
          - id: sample_done
            type: io.kestra.plugin.core.log.Log
            description: Record the healthy sample.
            message: "Sample execution for {{ inputs.service }}/{{ inputs.environment }}
              completed."

errors:
  - id: alert_failure
    type: io.kestra.plugin.slack.notifications.SlackIncomingWebhook
    description: Alert when seeding itself fails, since a half-seeded dashboard
      looks exactly like missing data.
    url: "{{ secret('SLACK_WEBHOOK_URL') }}"
    payload: |
      {
        "text": "Dashboard sample seeder FAILED in flow {{ flow.id }} (execution {{ execution.id }}). The dashboard may be partially seeded - check the plan step and re-run."
      }

outputs:
  - id: seed_summary
    type: JSON
    description: 'Planned sample executions and failing share - e.g. {"total": 12,
      "failing": 3, "items": [...]}.'
    value: "{{ outputs.plan_samples.vars | toJson }}"