Query your change tracking data

After setting up change tracking and viewing your changes in the New Relic UI, you can create custom queries to analyze change patterns, build dashboards, and set up automated reporting. This page shows you how to query change tracking data using NRQL and NerdGraph.

New Relic provides both NRQL and NerdGraph as to query change tracking data, each suited for different use cases.

Use NRQL for change tracking

Use NRQL to:

• Create dashboards: Build custom charts and visualizations for ongoing monitoring.
• Analyze time-series data: Correlate changes with performance metrics over time.
• Set up alerts: Create alert conditions based on change patterns.
• Perform statistical analysis: Calculate averages, percentages, and trends.

The following data sources are available for NRQL queries:

• ChangeTrackingEvent: Events created using the new changeTrackingCreateEvent mutation.
• Deployment: Legacy deployment events created using changeTrackingCreateDeployment as well as our legacy REST APIs.

FROM ChangeTrackingEvent, Deployment 
SELECT eventType(), deploymentId or changeTrackingId AS 'id', *
WHERE (eventType() = 'Deployment' OR (eventType() = 'ChangeTrackingEvent' AND category = 'Deployment'))
AND entity.name = '<your_service_name>'

NRQL query examples

Use these examples in the query builder or when creating dashboards and alerts.

SELECT *
FROM ChangeTrackingEvent
SINCE 1 week ago

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

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

Use NerdGraph for change tracking

Use NerdGraph when you want to:

• Programmatic access: Integrate change data into external tools and workflows.
• Cross-account queries: Retrieve data from multiple New Relic accounts.
• Real-time applications: Build applications that need live change data.
• Bulk data export: Extract large datasets for analysis in external systems.

The NerdGraph API offers several advantages for querying change tracking data:

• Access to related entity information
• Advanced filtering capabilities
• Cross-account data aggregation
• Real-time API responses

NerdGraph query examples

Use these examples in the NerdGraph explorer or in your applications.

{
  actor {
    changeTracking {
      changeTrackingSearch {
        changeEvents {
          shortDescription
          category
          changeTrackingId
          customAttributes
          description
          groupId
          timestamp
          type
          user
        }
      }
    }
  }
}

{
  actor {
    changeTracking {
      changeTrackingSearch(
        filter: {
          timeWindow: {
            startTime: INSERT_MS_EPOCH_TIMESTAMP
            endTime: INSERT_MS_EPOCH_TIMESTAMP
          }
          accountIds: INSERT_ACCOUNT_IDS
          query: "entity.guid='INSERT_ENTITY_GUID'"
        }
      ) {
        changeEvents {
          shortDescription
          category
          type
          changeTrackingId
          customAttributes
          description
          groupId
          timestamp
          user
          entity {
            guid
            accountId
          }
        }
      }
    }
  }
}

{
  actor {
    changeTracking {
      changeTrackingSearch(
        filter: { query: "user = 'ChangeTrackingUser'", limit: 10 }
      ) {
        changeEvents {
          shortDescription
          category
          type
          changeTrackingId
          customAttributes
          description
          groupId
          timestamp
          user
        }
      }
    }
  }
}

{
  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
        }
      }
    }
  }
}

NerdGraph optimization tips

• Request only needed fields: Specify only the fields you actually need
• Use appropriate filters: Apply filters server-side rather than client-side
• Batch related queries: Combine related queries in a single request
• Implement pagination: Use limit and cursor-based pagination for large datasets

Data retention and limits

Understanding data constraints helps you plan your analysis approach:

Related documentation