Tutorial NerdGraph: Visualize e configure as métricas clássicas de uma entidade

Golden metrics e golden tags são informações sobre uma entidade que consideramos mais importantes para essa entidade. Usamos essas informações para exibir uma breve visão geral de uma entidade em toda a New Relic. Você pode ver e contribuir com as definições padrão das métricas clássicas e tags neste repositório público.

Este documento explica como consultar a métrica personalizada de uma entidade utilizando o NerdGraph.

Buscar métricas clássicas

Ao buscar métricas clássicas para um GUID específico ou lista de GUIDS, as consultas fornecidas já estão filtradas para você. Você pode executar a consulta resultante como está no criador de consulta. A métrica resultante pode ser um TIMESERIES ou um valor único.

Aqui está um exemplo de uma consulta de atualizações clássicas para uma entidade de tabela do AWS DynamoDB com o GUID ENTITY_GUID.

SELECT average(provider.getSuccessfulRequestLatency.Average)
FROM DatastoreSample
WHERE entityGuid IN ('ENTITY_GUID') 
  AND provider = 'DynamoDbTable'
TIMESERIES

Você pode usar o NerdGraph para consultar as métricas clássicas de uma entidade específica; por exemplo:

{
  actor {
    entity(guid: "ENTITY_GUID") {
      goldenMetrics {
        metrics {
          query
          title
        }
      }
    }
  }
}

Buscar etiqueta dourada

As tags douradas são sempre representadas da mesma forma, sejam solicitadas por guid ou por entityType. Você sempre receberá a lista de chaves de tag consideradas mais importantes da entidade.

{
  actor {
    entity(guid: "ENTITY_GUID") {
      goldenTags {
        tags {
          key
        }
      }
    }
  }
}

Personalizar métricas clássicas e golden tag

Caso queira alterar as atualizações clássicas e golden tag com base nas especificidades do seu ambiente, você pode substituí-las em dois contextos diferentes, na sua conta ou em uma workload.

Substituir métricas clássicas ou golden tag para um tipo de entidade específico em toda a sua conta

Neste caso, as novas métricas clássicas ou a nova tag dourada serão aplicadas em todo o New Relic, convertendo sua nova métrica e tag como padrão para o tipo de entidade especificado.

Para fazer isso, você pode usar uma mutação NerdGraph para substituir as métricas clássicas de uma entidade específica.

mutation {
  entityGoldenMetricsOverride(
    context: { account: ACCOUNT_TO_OVERRIDE_GOLDEN_METRICS }
    domainType: { domain: DOMAIN, type: TYPE }
    metrics: [
      {
        eventId: EVENT_ID
        select: NRDB_QUERY_SELECT
        from: NRDB_QUERY_EVENT
        where: NRDB_QUERY_WHERE
        title: TITLE_OF_THE_METRIC
        facet: FACET
        name: NAME_OF_THE_METRIC
      }
    ]
  ) {
    errors {
      message
      type
    }
    metrics {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      metrics {
        definition {
          eventId
          facet
          from
          select
          where
        }
        name
        query
        title
      }
    }
  }
}

Onde:

• domainType: o tipo de entidade da métrica a ser substituída.

• context: O contexto para buscar as métricas clássicas. Nesse caso, você deve definir a conta que deseja substituir.

• metrics: A nova consulta do NRDB será mostrada como métricas clássicas.

  • eventId: o campo usado para filtrar a entidade na métrica. Como o GUID da entidade é definido no seu evento.
  • select: a cláusula SELECT da consulta NRDB. Este campo é required.
  • from: a cláusula FROM da consulta NRDB.
  • where: Cláusula complementar WHERE para identificação do campo tipo entidade.
  • facet: o campo para FACET.
  • title: O título das métricas clássicas. Este campo é opcional.
  • name: O nome das métricas clássicas. Este campo é required.

mutation {
  entityGoldenMetricsOverride(
    context: { account: ACCOUNT_ID }
    domainType: { domain: "APM", type: "APPLICATION" }
    metrics: [
      {
        eventId: "entity.guid"
        from: "Transaction"
        name: "cpuUsage"
        select: "max(cpuUsage)"
        title: "CPU Usage"
      }
      {
        eventId: "guid"
        from: "Metric"
        where: "metricTimesliceName in ('HttpDispatcher', 'OtherTransaction/all')"
        facet: "appName"
        select: "count(newrelic.timeslice.value)"
        name: "throughput"
        title: "Throughput"
      }
    ]
  ) {
    errors {
      message
      type
    }
    metrics {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      metrics {
        definition {
          eventId
          facet
          from
          select
          where
        }
        name
        query
        title
      }
    }
  }
}

O objeto de entrada de métricas define as partes de uma consulta NRDB, divididas em seções. Uma dessas seções é a eventId, que é usada para identificar o campo que define o GUID dentro do evento NRDB que você deseja usar como uma métrica dourada. Por exemplo:

SELECT average(provider.getSuccessfulRequestLatency.Average)
FROM DatastoreSample
WHERE entityGuid IN ('EntityGuid') AND
      provider = 'DynamoDbTable'
FACET entityName TIMESERIES

É definido da seguinte forma:

{
  "eventId": "entityGuid",
  "from": "DatastoreSample",
  "where": "provider='DynamoDbTable'",
  "facet": "entityName",
  "select": "average(provider.getSuccessfulRequestLatency.Average)",
  "name": "GetItem latency (ms)",
  "title": "GetItem latency (ms)"
}

Como você pode ver no objeto resultante, a cláusula where contém apenas o campo do provedor . O sistema adiciona a cláusula where ao campo eventId por padrão.

Você pode fazer o mesmo para a tag dourada usando esta mutação NerdGraph:

mutation {
  entityGoldenTagsOverride(
    context: { account: ACCOUNT_ID }
    domainType: { domain: "APM", type: "APPLICATION" }
    tags: [{ key: "applicationName" }, { key: "environment" }]
  ) {
    errors {
      message
      type
    }
    tags {
      context {
        account
      }
      domainType {
        domain
        type
      }
      tags {
        key
      }
    }
  }
}

Substituir métricas clássicas de um tipo de entidade específico em uma workload

Os workloads do New Relic fornecem uma visão agregada de dados de integridade e desempenho sobre um grupo de entidades. Os gráficos de série temporal exibidos para cada tipo de entidade em uma carga de trabalho são definidos pelas métricas douradas na conta da carga de trabalho.

Se você quiser personalizar ainda mais quais séries temporais serão mostradas para um tipo de entidade específico em uma workload específica, substitua as atualizações clássicas na conta pela seguinte mutação:

mutation {
  entityGoldenMetricsOverride(
    context: { guid: WORKLOAD_TO_OVERRIDE_GOLDEN METRICS }
    domainType: { domain: DOMAIN, type: TYPE }
    metrics: [
      {
        eventId: EVENT_ID
        select: NRDB_QUERY_SELECT
        from: NRDB_QUERY_EVENT
        where: NRDB_QUERY_WHERE
        title: TITLE_OF_THE_METRIC
        facet: FACET
        name: NAME_OF_THE_METRIC
      }
    ]
  ) {
    errors {
      message
      type
    }
    metrics {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      metrics {
        definition {
          eventId
          facet
          from
          select
          where
        }
        name
        query
        title
      }
    }
  }
}

Veja acima os detalhes de cada campo. Nesse caso, context é o GUID da workload.

mutation {
  entityGoldenMetricsOverride(
    context: { guid: WORKLOAD_ENTITY_GUID }
    domainType: { domain: "APM", type: "APPLICATION" }
    metrics: [
      {
        eventId: "entity.guid"
        from: "Transaction"
        name: "cpuUsage"
        select: "max(cpuUsage)"
        title: "CPU Usage"
      }
      {
        eventId: "guid"
        from: "Metric"
        where: "metricTimesliceName in ('HttpDispatcher', 'OtherTransaction/all')"
        facet: "appName"
        select: "count(newrelic.timeslice.value)"
        name: "throughput"
        title: "Throughput"
      }
    ]
  ) {
    errors {
      message
      type
    }
    metrics {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      metrics {
        definition {
          eventId
          facet
          from
          select
          where
        }
        name
        query
        title
      }
    }
  }
}

Busque as métricas clássicas personalizadas e a tag dourada

A consulta definida nas seções anteriores sempre retorna as métricas clássicas padrão e a golden tag. Caso queira buscar suas métricas clássicas customizadas ou golden tag, você precisa enviar o contexto definido na consulta, por exemplo:

{
  actor {
    entity(guid: INFRA_AWSDYNAMODBTABLE_GUID) {
      goldenMetrics(
        context: { account: ACCOUNT_ID, guid: WORKLOAD_ENTITY_GUID }
      ) {
        metrics {
          title
          query
          name
        }
      }
    }
  }
}

Para etiqueta dourada:

{
  actor {
    entity(guid: INFRA_AWSDYNAMODBTABLE_GUID) {
      goldenTags(context: { account: ACCOUNT_ID, guid: WORKLOAD_ENTITY_GUID }) {
        tags {
          key
        }
      }
    }
  }
}

Você pode enviar os dois contextos simultaneamente para consulta, caso sua métrica ou tag possua o contexto dentro da workload. A API retorna as métricas clássicas ou golden tag mais específicas com base no contexto que você definiu nas solicitações. A prioridade é workload e conta.

Reset métrica personalizada e tag dourada

Se suas métricas clássicas personalizadas não forem mais relevantes para você, você poderá restaurar os padrões definidos pela New Relic. No parâmetro context, defina a conta desejada ou o guia workload (no parâmetro guid).

Para restaurar suas métricas clássicas em uma conta, execute esta consulta:

mutation {
  entityGoldenMetricsReset(
    context: { guid: ACCOUNT_TO_OVERRIDE_GOLDEN_METRICS }
    domainType: { domain: DOMAIN, type: TYPE }
  ) {
    errors {
      message
      type
    }
    metrics {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      metrics {
        definition {
          eventId
          facet
          from
          select
          where
        }
        name
        query
        title
      }
    }
  }
}

Onde:

• domainType: o tipo de entidade da métrica a ser substituída.
• context: O contexto para buscar as métricas clássicas. Neste caso, você deve definir a conta que deseja redefinir.

Para restaurar suas métricas clássicas em uma workload, execute esta consulta:

mutation {
  entityGoldenMetricsReset(
    context: { guid: GUID_TO_OVERRIDE_GOLDEN_METRICS }
    domainType: { domain: DOMAIN, type: TYPE }
  ) {
    errors {
      message
      type
    }
    metrics {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      metrics {
        definition {
          eventId
          facet
          from
          select
          where
        }
        name
        query
        title
      }
    }
  }
}

Você pode fazer o mesmo com sua etiqueta dourada personalizada:

mutation {
  entityGoldenTagsReset(
    context: { guid: WORKLOAD_ENTITY_GUID }
    domainType: { domain: "APM", type: "APPLICATION" }
  ) {
    errors {
      message
      type
    }
    tags {
      context {
        account
        guid
      }
      domainType {
        domain
        type
      }
      tags {
        key
      }
    }
  }
}

Erro esperado

Todas essas mutações podem responder com o resultado da operação ou com uma lista de erros.

Estes são todos os erros esperados que você pode receber:

• INVALID_CONTEXT: o contexto não é válido. Só pode haver um contexto, uma conta ou um GUID de carga de workload. Se você usar ambos, ou qualquer outro conceito, ou um GUID que não pertença a uma workload, você receberá esse erro.
• INVALID_DOMAIN_TYPE: o tipo de domínio não é válido.
• LIMIT_EXCEEDED: O valor máximo da métrica é 9. Se você exceder esse limite, receberá este erro.
• NOT_AUTHORIZED: o usuário não tem permissões para realizar esta ação.