Demo Slack Attachments

Hello — this guide shows how to design Slack Block Kit messages (attachments + blocks) and integrate them into Jenkins notifications using the slackSend step. You’ll learn how Block Kit structures messages as JSON, how to prototype with the Block Kit Builder, and how to construct and send attachments from a Jenkins shared library. The Slack API messaging docs are a great reference:

Messaging docs: https://api.slack.com/messaging
Block Kit Builder: https://app.slack.com/block-kit-builder/

A screenshot of the Slack API documentation page titled "Creating rich message layouts," showing the left navigation menu and main content describing how to add blocks to messages. The browser window also shows tabs along the top and a small circular user photo in the upper-right.

Overview

Block Kit composes messages from modular blocks (e.g., section, divider, header, actions).
Use the Block Kit Builder to preview desktop and mobile renderings before sending.
Block Kit payloads are JSON. Build the structure locally or programmatically (Groovy) and send via Jenkins’s slackSend.

Quick notes:

Use the Block Kit Builder to prototype your JSON payload and test “Send to Slack” (you must be logged in). When integrating with Jenkins, construct the same JSON structure in Groovy and then either pass the Groovy list/map directly or convert it to a JSON string depending on your slackSend implementation.

Simple Block example (Block Kit)

{
  "type": "section",
  "text": {
    "type": "mrkdwn",
    "text": "New Paid Time Off request from <example.com|Fred Enriquez>\n\n<https://example.com|View request>"
  }
}

Block Kit Builder example (multiple blocks)

{
  "blocks": [
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "Hello, Assistant to the Regional Manager Dwight! *Michael Scott* wants to know where you'd like to take the Paper Company investors to dinner tonight.\n\n *Please select a restaurant:*"
      }
    },
    { "type": "divider" },
    {
      "type": "section",
      "text": {
        "type": "mrkdwn",
        "text": "*Farmhouse Thai Cuisine*\n:star::star::star::star: 1528 reviews\nThey do have some vegan options..."
      },
      "accessory": {
        "type": "image",
        "image_url": "https://s3-media3.fl.yelpcdn.com/bphoto/cZed05m9lC2FmA3Arue7A/o.jpg",
        "alt_text": "alt text for image"
      }
    }
  ]
}

Attachments + Blocks

An attachment is a wrapper that may contain fields such as color and a blocks array.
Many Slack integrations send attachments that include blocks for rich layouts.
Build your attachments payload in the same shape the Block Kit Builder shows, then deliver it via slackSend.

Example attachment payload (representative)

{
  "attachments": [
    {
      "color": "#f2c744",
      "blocks": [
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": "Hi devsecops"
          }
        },
        { "type": "divider" },
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": "*Farmhouse Thai Cuisine*\n:star::star::star::star: 1528 reviews\nThey do have some vegan options..."
          },
          "accessory": {
            "type": "image",
            "image_url": "https://s3-media3.fl.yelpcdn.com/bphoto/c7ed05m9lC2FmA3Arue7A/o.jpg",
            "alt_text": "alt text for image"
          }
        }
      ]
    }
  ]
}

You can test “Send to Slack” directly from the Block Kit Builder to a channel you choose (you must be logged in). The preview will match how Slack renders the message in-channel. When sent, a message similar to this appears in the selected channel.

A screenshot of a Slack workspace open to the #jenkins channel, showing Jenkins app notifications in the chat. Below the notifications is a user message containing Thai restaurant reviews with small food thumbnail images.

Integrating attachments into Jenkins

Jenkins’s Slack Notifications plugin exposes the slackSend pipeline step for sending messages.
Different plugin versions accept attachments differently: some accept Groovy lists/maps, others expect a JSON string. If necessary wrap your Groovy structure with groovy.json.JsonOutput.toJson(attachments).
Best practice: build the attachments payload as Groovy maps/lists in a shared library and call slackSend() in post-build steps.

Below is a compact, corrected Groovy function suitable for a shared library (save as vars/sendNotification.groovy). It:

selects color and emoji by build status,
composes an attachments payload with header, job fields, failed stage, and action buttons,
calls slackSend (either with Groovy structures or JSON string depending on your plugin).

// File: vars/sendNotification.groovy
def call(String buildStatus = 'STARTED') {
    buildStatus = buildStatus ?: 'SUCCESS'

    def color
    def emoji

    if (buildStatus == 'SUCCESS') {
        color = '#47ec05'
        emoji = ':vwl:'   // replace with the emoji name available in your Slack workspace
    } else if (buildStatus == 'UNSTABLE') {
        color = '#d5ee0d'
        emoji = ':deadpool:'
    } else {
        color = '#ec2805'
        emoji = ':hulk:'
    }

    // Allow an environment override for emoji if provided
    if (env.emoji) {
        emoji = env.emoji
    }

    def attachments = [
      [
        "color": color,
        "blocks": [
          [
            "type": "header",
            "text": [
              "type": "plain_text",
              "text": "K8S Deployment - ${env.deploymentName} Pipeline",
              "emoji": true
            ]
          ],
          [
            "type": "section",
            "fields": [
              [
                "type": "mrkdwn",
                "text": "*Job Name:*\n${env.JOB_NAME}"
              ],
              [
                "type": "mrkdwn",
                "text": "*Build Number:*\n${env.BUILD_NUMBER}"
              ]
            ],
            "accessory": [
              "type": "image",
              "image_url": "https://raw.githubusercontent.com/sidd-harth/numeric/main/images/jenkins-slack.png",
              "alt_text": "Jenkins Icon"
            ]
          ],
          [
            "type": "section",
            "text": [
              "type": "mrkdwn",
              "text": "*Failed Stage Name:* ${env.failedStage ?: 'none'}"
            ],
            "accessory": [
              "type": "button",
              "text": [
                "type": "plain_text",
                "text": "Jenkins Build URL",
                "emoji": true
              ],
              "value": "open_build",
              "url": "${env.BUILD_URL}",
              "action_id": "button-build-url"
            ]
          ],
          [ "type": "divider" ],
          [
            "type": "section",
            "fields": [
              [
                "type": "mrkdwn",
                "text": "*Kubernetes Deployment Name:*\n${env.deploymentName}"
              ],
              [
                "type": "mrkdwn",
                "text": "*Node Port*\n32564"
              ]
            ],
            "accessory": [
              "type": "image",
              "image_url": "https://raw.githubusercontent.com/sidd-harth/numeric/main/images/k8s-slack.png",
              "alt_text": "Kubernetes Icon"
            ]
          ],
          [
            "type": "section",
            "fields": [
              [
                "type": "mrkdwn",
                "text": "*Git Commit:*\n${env.GIT_COMMIT ?: 'n/a'}"
              ],
              [
                "type": "mrkdwn",
                "text": "*Previous Success Commit:*\n${env.GIT_PREVIOUS_SUCCESSFUL_COMMIT ?: 'n/a'}"
              ]
            ],
            "accessory": [
              "type": "image",
              "image_url": "https://raw.githubusercontent.com/sidd-harth/numeric/main/images/github-slack.png",
              "alt_text": "Github Icon"
            ]
          ],
          [
            "type": "section",
            "text": [
              "type": "mrkdwn",
              "text": "*Git Branch:* ${env.GIT_BRANCH ?: 'n/a'}"
            ],
            "accessory": [
              "type": "button",
              "text": [
                "type": "plain_text",
                "text": "Github Repo URL",
                "emoji": true
              ],
              "value": "open_repo",
              "url": "${env.GIT_URL ?: ''}",
              "action_id": "button-repo-url"
            ]
          ]
        ]
      ]
    ]

    // Option A: pass the attachments Groovy structure (some slackSend implementations accept this)
    // slackSend(iconEmoji: emoji, attachments: attachments)

    // Option B (safer): convert attachments to JSON string if required by your slackSend plugin
    // import groovy.json.JsonOutput
    // slackSend(iconEmoji: emoji, attachments: JsonOutput.toJson(attachments))

    // Uncomment and use whichever form your Jenkins endpoint expects:
    slackSend(iconEmoji: emoji, attachments: attachments)
}

Call from your Jenkinsfile

Ensure the shared library is configured and the library name matches your @Library('...') directive.
Call sendNotification from post-build blocks (e.g., success, failure) and set helpful environment variables like failedStage and emoji to provide contextual data.

Example snippet from a Jenkinsfile (declarative pipeline):

@Library('slack') _
pipeline {
    agent any

    environment {
        deploymentName = "devsecops"
        applicationURL = "http://devsecops-demo.eastus.cloudapp.azure.com"
    }

    stages {
        stage('Testing Slack') {
            steps {
                // A simple step to create a successful run for testing notifications
                sh 'exit 0'
            }
        }
    }

    post {
        success {
            script {
                env.failedStage = "none"
                env.emoji = ':white_check_mark: :tada: :thumbsup_all:'
                // Call shared library function
                sendNotification currentBuild.result
            }
        }
        failure {
            script {
                // set a failed stage name before calling sendNotification
                env.failedStage = env.failedStage ?: 'unknown'
                sendNotification currentBuild.result
            }
        }
    }
}

Troubleshooting and tips

If junit fails with “Test reports were found but none of them are new,” it means test results were published but no tests ran in this build. Guard or comment out report publishers when you skip tests during Slack testing.
If Jenkins errors with “No such DSL method ‘sendNotifications’ found”, confirm the shared library function name matches the call site (sendNotification vs sendNotifications).
If images/icons do not appear:
- Ensure image URLs are publicly accessible.
- Alternatively upload the images to Slack and use a custom emoji name for iconEmoji.
- Custom emoji names must match exactly when referenced (e.g., :deadpool:).

If your slackSend implementation requires a JSON string for attachments, convert the Groovy structure with groovy.json.JsonOutput.toJson(attachments) before sending. Also verify that image URLs are reachable from Slack (public or Slack-hosted).

Uploading custom emojis

In Slack: Workspace menu → Customize → Emoji, upload an image, assign a name, and then use that name (for example, :deadpool:) with iconEmoji in slackSend.

A Slack workspace window with the "Add emoji" dialog open, showing an uploaded deadpool.png preview and the name field for the custom emoji. In the background the #jenkins channel and messages are visible.

Testing and expected results

After configuring the shared library and payload, run a test build that triggers the post step.
A successful message will include:
- header with pipeline name,
- job name and build number,
- failed stage (if any),
- Kubernetes deployment info and node port,
- Git commit and branch info,
- action buttons for Jenkins build and Git repo URLs.

Example Jenkins build screenshot (for sanity check):

Final Slack message example (what you should see in the channel):

A screenshot of a Slack workspace open to the #jenkins channel showing a Jenkins Slack App message about a "K8S Deployment - devsecops Pipeline" with job details (job name, build number, Kubernetes node port, Git commit, etc.). The left sidebar shows other channels and apps while the main pane displays the deployment notification and action buttons.

Quick reference table

Concept	Jenkins / Groovy example	Notes
Pipeline step	`slackSend(iconEmoji: emoji, attachments: attachments)`	Some versions expect `attachments` as a JSON string.
Convert to JSON	`groovy.json.JsonOutput.toJson(attachments)`	Use when `slackSend` rejects Groovy maps/lists.
Environment vars	`env.BUILD_NUMBER`, `env.JOB_NAME`, `env.GIT_COMMIT`	Set `env.failedStage` before calling `sendNotification`.
Custom emoji	`env.emoji = ':deadpool:'`	Upload emoji in Slack and use that name in `iconEmoji`.

Links and references

Slack Block Kit docs: https://api.slack.com/messaging
Block Kit Builder: https://app.slack.com/block-kit-builder/
Jenkins Pipeline Syntax & Shared Libraries: https://www.jenkins.io/doc/book/pipeline/shared-libraries/

Wrap-up

Prototype Block Kit messages in the Block Kit Builder, then recreate the same attachments/blocks structure in Groovy.
Keep the payload consistent between Block Kit Builder and Jenkins; convert to JSON if your plugin requires a string.
Upload any custom icons to Slack and reference them via iconEmoji when calling slackSend.
Add logic in your shared library to capture failed stage names and other contextual metadata to improve the usefulness of notifications.

Introduction

DevSecOps Pipeline

Kubernetes Operations and Security

HashiCorp Vault + Kubernetes

Additional Topics

DevOps Pipeline

Demo Slack Attachments

Watch Video