How to view and analyze your changes in New Relic

When you use the change tracking feature in New Relic, you can see how recent changes, such as deployments, affect your end users. For example, you can see app server Apdex scores, response times, throughput, and errors. You can view and drill down details, use search and sort options, hide or delete the error, share it with others, or file a ticket about it.

Before you jump into the details here about how to view and analyze the impact of changes, make sure you've designated the changes you want to monitor using GraphQL, our CLI, or a CI/CD integration. After you've designated which changes to track, you are ready to see the results from across your stack in a number of ways:

• Charts in APM and dashboards: A vertical line with a pinhead appears on time series charts. This marker represents the recorded change, and if you click on the pinhead, you can start drilling into the impact the change had on entity health and quality.

  Tip

  If you land on a dashboard or entity summary page and don't see the deployment marker you're expecting, check your time picker selection. It might be outside the window you are looking at.

• Entity sidebar: On the sidebar for any entity with recorded deployments, you can click on Deployments preview to see a table displaying recorded deployments. This is the deployments list page, and it features a time range selector and table filtering and sorting options. Use these to narrow the field of deployments or find a specific deployment.

  

  Tip

  Note that you may need to adjust the selected time range on this page to see deployments. Also, by default the table will only lazy load up to 2,000 deployments. Keep this in mind as you're filtering, searching, and adjusting your time range.

• New Relic Alerts & Detection: If your deployment is related to an issue, you'll see it listed on the Deployments table of the Root Cause Analysis section of the Issues page.

  

• Activity stream component: You can see recorded deployment events in the activity feed on the right collapsible panel on various pages across the New Relic UI.

  

Analyze the impact of your deployment

How have your deployments affected your sytems? We offer a number of ways to analyze the effects of your deployments.

Deployment details page

Clicking on a deployment virtually anywhere in New Relic—on a chart, on the Issues page, and so on—will open a Deployment details page containing the data you sent when you recorded the deployment plus a wealth of information about its impact.

You'll get various insights into how this deployment may have have affected this entity's health, performance, and quality. These insights are based on errors, key metrics and log attribute trends, anomalies, issues, and more. This page also features powerful scoping and comparison tools to help you see and understand even more context about ongoing changes. For example, you can see how this deployment compares to the one before.

Here are some helpful insights you can get by recording deployments and leveraging other New Relic features:

• Calculated net impacts of the change on key entity signals, such as throughput, error rate, transaction time, and more. You can see the net impact on a signal above each time series chart (typically shown as a percentage). Note that these net impacts are usually calculated by comparing averages or some other function of the signal before and after the deployment (hover over net impact figures to see before/after averages, etc.).

  You can adjust the before/after period used in these calculations and displayed on time series charts via the timepicker at the top right corner of the deployment details page.

  Tip

  Pay close attention to the selected before/after time period as you analyze the impact of a change. If the period is too short or too long for your specific needs, just adjust it. Note that the UI will not calculate net impacts if elapsed time since the deployment is less than your selected before/after period because doing so results in skewed and generally unhelpful results.

• Faceted findings from a variety of New Relic products including errors inbox, log monitoring, AIOps (issues, incidents, and anomalies), and more show how this deployment has affected or relates to crucial troubleshooting and analysis records. The insights featured here and how data is filtered will vary by entity type. Hover over titles of page sections to learn more about how we surface meaningful insights here.

  

  Tip

  The page-level timepicker also affects facet insights from other New Relic products. Try zeroing in on the time period after a deployment that matters most to you.

• A link (See all deployments on this entity) to a page containing the aforementioned deployments list page filtered to this entity. Use this to quickly zoom out and see all recent changes on this part of your system.

• Links to entities related to this deployment's entity. This helps you move across your stack as you look for the source of a problem or measure the impact of changes stemming from this deployment.

• All the data supplied when the deployment was recorded, which helps anyone quickly understand context—regardless of whether they made the change or not.

  Tip

  When you record a deployment, try submitting a URL for the changelog attribute. The UI will render it as a clickable link that serves as a convenient jumping-off point to your source repo management system.

Change the before/after comparison period

The Deployment details page hinges on the idea that records and signals generated over a period of time leading up to this deployment are being compared with a period of equal length following this deployment. You can change the length of that period using a time picker in the top-right corner. Note that this will affect both time series charts and other UI elements featuring data-driven insights.

Compare one deployment to another

Next to the timepicker in the top-right corner of the Deployment details page, you will see compared with next to a dropdown menu. Using that dropdown menu, you can select another recorded deployment. This will toggle the Deployment marker details page to a comparative mode.

When you compare deployments:

• Each time series chart will show a curve for THIS deployment and THAT deployment, which will help you compare the relative performance of each deployment.

  

• Other calculations on this page will update to help you understand the difference between THIS deployment and THAT deployment. They may show increases/decreases in percentages for rates or counts (for example, +11) where it makes sense to do so.

• You can open up to five stacked views of related deployments.

Query deployments data

You can also query deployments data via NRQL (the query language for the New Relic database) or through NerdGraph (the New Relic GraphQL API).

Take a look at the NRQL and GraphQL sections below for some examples, or if you need more help using the query tools, see Introduction to NRQL, Introduction to New Relic NerdGraph, or NerdGraph entities API tutorial.

NRQL

After you create a marker using GraphQL, you can use NRQL in the query builder to create time series charts, draw curves for a telemetry signal over a span of time, and render deployments as markers.

Try these examples or create your own queries:

SELECT *
FROM Deployment
SINCE 30 days ago

SELECT COUNT(*)
FROM TransactionError
WHERE  appName = 'INSERT_YOUR_APP_NAME' AND http.statusCode > 300
SINCE 1 month ago TIMESERIES

SELECT COUNT(*)
FROM Transaction
WHERE appName = 'INSERT_YOUR_APP_NAME'
FACET name
LIMIT  MAX
SINCE 1 week ago TIMESERIES

NerdGraph (GraphQL)

Try these NerdGraph queries in our NerdGraph explorer:

{
  actor {
    entity(guid: "INSERT_YOUR_GUID_HERE") {
      deploymentSearch(
        filter: {
          timeWindow: {
            endTime: INSERT_MS_EPOCH_TIMESTAMP
            startTime: INSERT_MS_EPOCH_TIMESTAMP
          }
        }
      ) {
        results {
          version
          entityGuid
          timestamp
        }
      }
    }
  }
}

{
  actor {
    entity(guid: "INSERT_YOUR_GUID_HERE") {
      deploymentSearch(
        filter: {
          timeWindow: {
            endTime: INSERT_MS_EPOCH_TIMESTAMP
            startTime: INSERT_MS_EPOCH_TIMESTAMP
          }
          query: "user = 'Test User'"
        }
      ) {
        results {
          version
          entityGuid
          timestamp
          changelog
          commit
          deepLink
          deploymentId
          description
          deploymentType
          groupId
          user
        }
      }
    }
  }
}

{
  actor {
    entity(guid: "INSERT_YOUR_GUID_HERE") {
      deploymentSearch(
        filter: {
          timeWindow: {
            endTime: INSERT_MS_EPOCH_TIMESTAMP
            startTime: INSERT_MS_EPOCH_TIMESTAMP
          }
          query: "((user = 'Test User' AND version = '1.0') OR deploymentType in ('BLUE_GREEN', 'CANARY'))"
          limit: 200
        }
      ) {
        results {
          changelog
          commit
          deepLink
          deploymentId
          deploymentType
          description
          entityGuid
          groupId
          timestamp
          user
          version
        }
      }
    }
  }
}

If you haven't already, create your free New Relic account below to start monitoring your data today.