흐름흐름 정의 스키마

workflowInputs:
  myInput1:
    type: String
  myInput2:
    type: Number
    defaultValue: 42

name: calendar_demo

workflowInputs:
  timezone:
    type: String
    defaultValue: 'America/Los_Angeles'
    validations:
      - type: regex
        errorMessage: "The provided timezone is not correct"
        pattern: "^[A-Za-z]+\/[A-Za-z_]+(?:\/[A-Za-z_]+)?$"

      - type: maxLength
        errorMessage: "Timezone length should be less than 100"
        length: 100
      
  accountId:
    type: Int
    validations:
      - type: minIntValue
        errorMessage: "Account id should be greater than 100000"
        minValue: 100000
      - type: maxIntValue
        errorMessage: "Account id should be less than 9999999"
        maxValue: 9999999

steps:
  - name: getCurrentTime
    type: action
    action: http.get
    version: 1
    inputs:
      url: 'https://worldtimeapi.org/api/timezone/${{ .workflowInputs.timezone }}'
      selectors:
        - name: timezone
          expression: '.responseBody | fromjson.abbreviation'
        - name: datetime
          expression: '.responseBody | fromjson.datetime'

name: testWorkflowConstantsWithJQ
 description: Test workflow to demonstrate workflowConstants usage
  steps:
    - name: logWithConstants
      type: action
      action: newrelic.ingest.sendLogs
      version: '1'
      inputs:
        logs:
          - message: Workflow Execution Started
            attributes:
              accountId: ${{ .workflowConstants.accountId }}
              orgId: ${{ .workflowConstants.organizationId }}
              version: ${{ .workflowConstants.definitionVersion }}
              scopeType: ${{ .workflowConstants.definitionScopeType }}
              startedAt: ${{ .workflowConstants.startedAt }}
              runId: ${{ .workflowConstants.runId }}
              workflowDefinitionName: ${{ .workflowConstants.definitionName }}

steps:
    - name: transformConstants
      type: action
      action: newrelic.ingest.sendLogs
      version: '1'
      inputs:
        logs:
          - message: Testing JQ transformations on workflowConstants
            attributes:
              # Convert epoch milliseconds to ISO8601 format
              startedAtISO8601: ${{ (.workflowConstants.startedAt / 1000) | todateiso8601 }}
              # Convert to uppercase
              runIdUppercase: ${{ .workflowConstants.runId | ascii_upcase }}
              # Get string length
              definitionNameLength: ${{ .workflowConstants.definitionName | length }}
              # Convert to string
              accountIdString: ${{ .workflowConstants.accountId | tostring }}
              # Combine multiple constants
              combinedMetadata: ${{ .workflowConstants.definitionName + "-" + .workflowConstants.runId }}

steps:
    - name: convertStartedAtFromEpoch
      type: action
      action: utils.datetime.fromEpoch
      version: 1
      inputs:
        timestamp: ${{ .workflowConstants.startedAt }}
        timezoneId: UTC
        pattern: "yyyy-MM-dd HH:mm:ss"
        timestampUnit: MILLISECONDS
        selectors:
          - name: datetime
            expression: ".datetime"
          - name: timezone
            expression: ".timezone"

name: calendar_demo

  workflowInputs:
    timezone:
      type: String
      defaultValue: 'America/Los_Angeles'
    accountId:
      type: Int

  steps:
    - name: getCurrentTime
      type: action
      action: http.get
      version: 1
      inputs:
        url: 'https://worldtimeapi.org/api/timezone/${{ .workflowInputs.timezone }}'
        selectors:
          - name: timezone
            expression: '.responseBody | fromjson.abbreviation'
          - name: datetime
            expression: '.responseBody | fromjson.datetime'

name: myRangeIterator
steps:
  - name: looper
    type: loop
    for:
      # iterate over [1..5]
      in: ${{ [range(1; 6)] }}
      steps:
        - name: logProgress
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Element: ${{ .steps.looper.loop.element | tostring }}" # not exist outside of this loop
                attributes:
                  # ranges over [0..4]
                  index: ${{ .steps.looper.loop.index }}

name: process-orders
description: Process and validate orders

workflowInputs:
  validStatuses:
    type: List
    defaultValue: ["pending", "confirmed", "shipped"]

steps:
  - name: getOrders
    type: assign
    inputs:
      orders:
        - { id: "001", status: "pending", amount: 100 }
        - { id: "002", status: "invalid", amount: 50 }
        - { id: "003", status: "shipped", amount: 200 }

  - name: processOrders
    type: loop
    for:
      in: ${{ .steps.getOrders.outputs.orders }}
      steps:
        - name: validateStatus
          type: switch
          switch:
            - condition: ${{ .steps.processOrders.loop.element.status as $status | .workflowInputs.validStatuses | index($status) != null }}
              next: validOrder
          next: invalidOrder

        - name: invalidOrder
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Invalid order status"
                attributes:
                  orderId: ${{ .steps.processOrders.loop.element.id }}
                  status: ${{ .steps.processOrders.loop.element.status }}

        - name: validOrder
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Processing valid order"
                attributes:
                  orderId: ${{ .steps.processOrders.loop.element.id }}
                  status: ${{ .steps.processOrders.loop.element.status }}
                  amount: ${{ .steps.processOrders.loop.element.amount }}

name: myMapIterator
steps:
  - name: looper
    type: loop
    for:
      in: '${{ [ {"key1": "val1"}, {"key2": "val2"} ] }}'
      steps:
        - name: logProgress
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "Element: ${{ .steps.looper.loop.element | tostring }}"

name: myLoopJump
steps:
  - name: fistStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "the first step"
  - name: loopStep
    type: loop
    for:
      in: ${{ [range(1; 6)] }}
      steps:
        - name: loopStep1
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop first step"
          next: loopStep3                         # Okay within the loop
        - name: loopStep2
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop second step, never executed"
        - name: loopStep3
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop third step"
          next: fistStep                        # Not okay, first step is not in the loop context

name: myLoopContinueBreak
steps:
  - name: fistStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "the first step"
  - name: loopStep
    type: loop
    for:
      in: ${{ [range(1; 6)] }}
      steps:
        - name: loopStep1
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop first step"
          # continue with next iteration without executing loopStep2
          next: continue
        - name: loopStep2
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop second step, never executed"

  - name: loopAgain
    type: loop
    for:
      in: ${{ [range(1; 6)] }}
      steps:
        - name: loopAgainStep1
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop again first step"
          # stop iterating and continue with next step after the loop
          next: break
        - name: loopAgainStep2
          type: action
          action: newrelic.ingest.sendLogs
          version: 1
          inputs:
            logs:
              - message: "the loop again second step, never executed"

  - name: lastStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "the last step"

- name: hasCompleted
    type: switch
    switch:
      - condition: ${{ .steps.waitForCompletion.outputs.automationExecutionStatus == "Failed" }}
        next: displayError
      - condition: ${{ .steps.waitForCompletion.outputs.automationExecutionStatus == "Success" }}
        next: displaySuccess
    next: displayUnexpected

name: waitSignalExample
steps:
  - name: waitStep
    type: wait
    seconds: 300
    signals: [{name: 'mySignal', next: 'mySignalHandler'}]
  - name: endStep
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "didn't get signal"
    next: end
  - name: mySignalHandler
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        # log entry "got signal with data bar" when using signalInputs [{"foo": "bar"}]
        - message: "got signal with data ${{ .steps.waitStep.outputs.signalInputs.foo }}"

name: sampleWorkflowWithAssign

workflowInputs:
  initialValue:
    type: String
    defaultValue: "abcd"
  anotherValue:
    type: Int
    defaultValue: 1234

steps:
  - name: variableInitialization
    type: assign
    inputs:
      stringVar: "${{ .workflowInputs.initialValue }}"
      intVar: "${{ .workflowInputs.anotherValue }}"
      concatenationVar: "${{ .workflowInputs.initialValue }} - concatenated"
      booleanVar: true
      mapVar:
        key1: "value1"
        key2: "${{ .workflowInputs.initialValue }}"
      listVar:
        - "listItem1"
        - "${{ .workflowInputs.initialValue }}"
        - "${{ .workflowInputs.anotherValue }}"

  - name: logVariables
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "stringVar: ${{ .steps.variableInitialization.outputs.stringVar }}"
        - message: "intVar: ${{ .steps.variableInitialization.outputs.intVar }}"
        - message: "concatenationVar: ${{ .steps.variableInitialization.outputs.concatenationVar }}"
        - message: "booleanVar: ${{ .steps.variableInitialization.outputs.booleanVar }}"
        - message: "mapVar: ${{ .steps.variableInitialization.outputs.mapVar | tojson }}"
        - message: "listVar: ${{ .steps.variableInitialization.outputs.listVar | tojson }}"

name: workflow-state-example
description: Store and retrieve state across steps
steps:
  - name: storeInitialData
    type: state
    inputs:
      count: 1
      foo: "bar"
  - name: updateCount
    type: state
    inputs:
      color: "green"
      count: 2
  - name: logState
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "foo=${{ .workflowState.foo }}, color=${{ .workflowState.color }}, count=${{ .workflowState.count }}"

name: sendLogWorkflow
description: 'This workflow send Logs to newrelic'
steps:
  - name: sendLog
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: Sending Logs to NewRelic
  - name: error_4
    type: error
    condition: ${{.steps.sendLog.outputs.success == false}}
    message: Terminating Workflow as sendLog failed.
    next: end

steps:
  - name: mySecretStep
    type: action
    action: newrelic.instrumentation.log
    inputs:
      message: My message
      licenseKey: ${{ :secrets:<SECRET_NAME> }}

steps:
    - name: bearer_auth
      type: action
      action: utils.http.post
      inputs:
        headers:
          Authorization: Bearer ${{ :secrets:<SECRET_NAME> }}

name: calendar_demo

steps:
  - name: getUserCreated
    type: action
    action: newrelic.nerdgraph.execute
    version: 1
    inputs:
      graphql: |
        {
          actor {
            user {
              id
              createdAt
              timeZoneName
            }
          }
        }
      selectors:
        - name: id
          expression: ".data.actor.user.id"
        - name: createdAt
          expression: ".data.actor.user.createdAt"
        - name: timeZoneName
          expression: ".data.actor.user.timeZoneName"

  - name: getCreatedTime
    type: action
    action: utils.datetime.fromEpoch
    version: 1
    inputs:
      timestamp: ${{ .steps.getUserCreated.outputs.createdAt }}
      pattern: "yyyy-MM-dd HH:mm:ss"
      timezoneId: ${{ .steps.getUserCreated.outputs.timeZoneName }}
      selectors:
        - name: datetime
          expression: ".datetime"
        - name: abbreviation
          expression: ".timezone.abbreviation"

  - name: logTime
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "Demo ${{ .workflowConstants.runId }} userId ${{ .steps.getUserCreated.outputs.id }} created at ${{ .steps.getCreatedTime.outputs.datetime }} ${{ .steps.getCreatedTime.outputs.abbreviation }}"

  - name: wait
    type: wait
    seconds: 1

  - name: queryForLog
    type: action
    action: newrelic.nrdb.query
    version: 1
    inputs:
      query: "FROM Log SELECT message, timestamp SINCE 5 minute ago WHERE message LIKE 'Demo ${{ .workflowConstants.runId }} userId ${{ .steps.getUserCreated.outputs.id }} created at%'"

  - name: checkQuery
    type: switch
    switch:
      - condition: ${{ .steps.queryForLog.outputs.results | length > 0 }}
        next: postResultsMessage

  - name: postWaitingMessage
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "Waiting for log message..."
    next: wait

  - name: postResultsMessage
    type: action
    action: newrelic.ingest.sendLogs
    version: 1
    inputs:
      logs:
        - message: "Found log message! ${{ .steps.queryForLog.outputs.results[0].message }}"