> For the complete documentation index, see llms.txt.
Skip to main content

Check out Port for yourself ➜ 

Respond to New Relic alerts

Implement with AI

Send this guide to your coding agent.

Prerequisite: Install Port MCP

Open in ClaudeOpen in CodexOpen in Cursor
Open plan mode. Implement this Port guide in my org via MCP:

https://docs.port.io/guides/all/respond-to-new-relic-alerts

Goal: get the guide's core flow working end-to-end in my org; adapting it to fit my existing setup takes priority over matching the guide 1:1.

Plan:
1. Confirm MCP is connected, in the right org, with sufficient permissions.
2. Diff the guide's data model (blueprints, properties, relations, actions, agents, automations, integrations, secrets) against mine.
3. Propose adaptations for gaps, reusing existing blueprints/relations over guide-named duplicates.
4. Flag what needs a UI click, credential, or secret from me, testing MCP capability empirically before ruling anything out.
5. Stop on any blocker and give me options. Approving this plan authorizes the writes it lists; pause only for writes beyond what's listed.

Build:
- Extend blueprint schema additively when upserting; don't remove or overwrite existing properties, and treat type conflicts as a blocker, not an auto-fix.
- List any mock data in the plan, minimal and labeled mock; once approved, seed it without re-asking, and tell me what you seeded.
- For anything the guide writes downstream (e.g. a webhook target), use a real entity, not a mock.
- For pages/widgets, use the real page identifier from the app URL, not a guessed slug.
- When you hit a UI step confirmed (not assumed) unsupported via MCP, pause, give exact clicks, then resume via MCP.
- Validate and give links after each meaningful step (only a tool-returned URL, no guessed paths); don't proceed if the last run wasn't a success.

Done:
- Confirm the guide's expected output exists and runs in Port.
- Summarize adaptations, seeded data, what was mocked or skipped, remaining UI steps, and how to verify.

This guide demonstrates how to respond to New Relic alerts by creating Jira issues or PagerDuty incidents through Port using a synced webhook or GitHub workflow.

The PagerDuty response path uses the relationships in your software catalog to preselect the affected service and route the incident with New Relic alert context.

Prerequisites​

To create Jira issues, you also need:

  • Access to your Jira organization with permission to create issues.
  • A Jira API token with permission to create issues.
  • Port's Jira integration, or the ability to create the Jira issue blueprint manually.

Set up data model​

The New Relic, Jira, and PagerDuty integrations create their respective blueprints automatically. If you do not install one of these integrations, use the relevant steps below to create its blueprints manually.

Create the New Relic alert blueprint​

  1. Go to the Builder page of your portal.

  2. Click on + Blueprint.

  3. Click on Edit JSON.

  4. Copy and paste the following JSON configuration into the editor:

    New Relic alert blueprint (Click to expand)
    {
      "identifier": "newRelicAlert",
      "description": "This blueprint represents a New Relic alert in our software catalog",
      "title": "New Relic Alert",
      "icon": "NewRelic",
      "ownership": {
        "type": "Inherited",
        "title": "Owning Teams",
        "path": "alert_to_workload.service"
      },
      "schema": {
        "properties": {
          "priority": {
            "type": "string",
            "title": "Priority",
            "enum": [
              "CRITICAL",
              "HIGH",
              "MEDIUM",
              "LOW"
            ],
            "enumColors": {
              "CRITICAL": "red",
              "HIGH": "red",
              "MEDIUM": "yellow",
              "LOW": "green"
            }
          },
          "state": {
            "type": "string",
            "title": "State",
            "enum": [
              "ACTIVATED",
              "CLOSED",
              "CREATED"
            ],
            "enumColors": {
              "ACTIVATED": "yellow",
              "CLOSED": "green",
              "CREATED": "lightGray"
            }
          },
          "sources": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "title": "Sources"
          },
          "alertPolicyNames": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "title": "Alert Policy Names"
          },
          "conditionName": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "title": "Condition Name"
          },
          "link": {
            "type": "string",
            "title": "Link",
            "format": "url"
          },
          "description": {
            "type": "string",
            "title": "Description"
          },
          "activatedAt": {
            "type": "string",
            "title": "Activated at",
            "format": "date-time"
          }
        },
        "required": []
      },
      "mirrorProperties": {
        "cloud_resource_name": {
          "title": "Cloud Resource",
          "path": "cloud_resource.$title"
        },
        "port_service": {
          "title": "Service",
          "path": "alert_to_workload.service.$title"
        },
        "team": {
          "title": "Team",
          "path": "alert_to_workload.service.$team"
        },
        "workload_name": {
          "title": "Workload name",
          "path": "alert_to_workload.$title"
        },
        "pager_duty_service": {
          "title": "PagerDuty service",
          "path": "alert_to_workload.service.pager_duty_service.$identifier"
        }
      },
      "calculationProperties": {},
      "aggregationProperties": {},
      "relations": {
        "alert_to_workload": {
          "title": "Workload",
          "target": "workload",
          "required": false,
          "many": false
        },
        "cloud_resource": {
          "title": "Cloud resource",
          "target": "newRelicCloudResource",
          "required": false,
          "many": false
        }
      }
    }

  5. Click Save to create the blueprint.

Create the Jira issue blueprint

  1. Go to the Builder page of your portal.

  2. Click on + Blueprint.

  3. Click on Edit JSON.

  4. Copy and paste the following JSON configuration into the editor:

    Jira issue blueprint (Click to expand)
    {
      "identifier": "jiraIssue",
      "title": "Jira Issue",
      "icon": "Jira",
      "schema": {
        "properties": {
          "url": {
            "title": "Issue URL",
            "type": "string",
            "format": "url",
            "description": "URL to the issue in Jira"
          },
          "status": {
            "title": "Status",
            "type": "string",
            "description": "The status of the issue"
          },
          "issueType": {
            "title": "Type",
            "type": "string",
            "description": "The type of the issue"
          },
          "components": {
            "title": "Components",
            "type": "array",
            "description": "The components related to this issue"
          },
          "assignee": {
            "title": "Assignee",
            "type": "string",
            "format": "user",
            "description": "The user assigned to the issue"
          },
          "reporter": {
            "title": "Reporter",
            "type": "string",
            "description": "The user that reported the issue",
            "format": "user"
          },
          "priority": {
            "title": "Priority",
            "type": "string",
            "description": "The priority of the issue"
          },
          "created": {
            "title": "Created at",
            "type": "string",
            "description": "The date and time when the issue was created",
            "format": "date-time"
          },
          "updated": {
            "title": "Updated at",
            "type": "string",
            "description": "The date and time when the issue was updated",
            "format": "date-time"
          }
        }
      },
      "calculationProperties": {},
      "relations": {}
    }

  5. Click Save to create the blueprint.

Create alert response​

Choose where you want to create the response, then select the synced webhook or GitHub workflow backend.

Create a Jira issue

Use this path to turn a New Relic alert into a Jira bug that includes the alert description, link, and reporting user.

The synced webhook calls Jira's API directly from Port.

Add Port secret

Existing secrets

If you have already installed Port's Jira integration, these secrets should already exist in your portal.
To view your existing secrets:

  1. In your Port application, click on your profile picture .
  2. Choose Credentials, then click on the Secrets tab.

Add a Base64-encoded Jira credential to your portal:

  1. In Port, click on your profile picture .

  2. Click on Credentials.

  3. Click on the Secrets tab.

  4. Click on + Secret and add JIRA_AUTH. Generate its value by running:

    echo -n "your-email@domain.com:your-api-token" | base64

    Replace your-email@domain.com with the Jira user's email and your-api-token with that user's Jira API token. You only need to regenerate the value when the email or token changes.

Set up self-service action

Follow the steps below to create a self-service action that calls the Jira API.

  1. Go to the Self-service page of your portal.

  2. Click on the + New Action button.

  3. Click on the {...} Edit JSON button.

  4. Copy and paste the following JSON configuration into the editor:

    Report a bug from a New Relic alert (Click to expand)
    {
      "identifier": "report_a_jira_bug_from_new_relic_alert",
      "title": "Report a bug from New Relic alert (Webhook)",
      "icon": "Jira",
      "description": "Report a Jira bug in Port based on a New Relic alert.",
      "trigger": {
        "type": "self-service",
        "operation": "DAY-2",
        "userInputs": {
          "properties": {
            "project": {
              "title": "Project",
              "description": "The Jira project where the bug will be created",
              "icon": "Jira",
              "type": "string",
              "blueprint": "jiraProject",
              "format": "entity"
            }
          },
          "required": [
            "project"
          ],
          "order": [
            "project"
          ]
        },
        "blueprintIdentifier": "newRelicAlert"
      },
      "invocationMethod": {
        "type": "WEBHOOK",
        "url": "https://<JIRA_ORGANIZATION_URL>.atlassian.net/rest/api/3/issue",
        "agent": false,
        "synchronized": true,
        "method": "POST",
        "headers": {
          "Authorization": "Basic {{ .secrets.JIRA_AUTH }}",
          "Content-Type": "application/json"
        },
        "body": {
          "fields": {
            "project": {
              "key": "{{ .inputs.project.identifier }}"
            },
            "summary": "Bug | New Relic | {{ .entity.title }}",
            "description": {
              "version": 1,
              "type": "doc",
              "content": [
                {
                  "type": "paragraph",
                  "content": [
                    {
                      "type": "text",
                      "text": "\nNew Relic description: {{ .entity.properties.description }}\n\nNew Relic link: {{ .entity.properties.link }}"
                    }
                  ]
                },
                {
                  "type": "paragraph",
                  "content": [
                    {
                      "type": "text",
                      "text": "Reported by: {{ .trigger.by.user.email }}"
                    }
                  ]
                }
              ]
            },
            "issuetype": {
              "name": "Bug"
            }
          }
        }
      },
      "requiredApproval": false
    }

    Replace <JIRA_ORGANIZATION_URL> with your Jira organization subdomain. For example, use example for https://example.atlassian.net.

  5. Click Save to create the action.

Test the flow

  1. Go to the Self-service page of your portal.

  2. Run the Report a bug from New Relic alert (Webhook) action.

  3. Select the New Relic alert and the Jira project where you want to create the bug.

  4. Click Execute.

  5. Confirm that the new bug appears in the selected Jira project.