Uma maneira de gerenciar sua ingestão de dados é usar as Pipeline cloud regras do Controle de . Para criar Pipeline cloud regras , você deve New Relic Compute adotar o preço baseado no uso .

Existem duas categorias de regras que você pode criar:

• Regra de descarte de dados

  • Remova tipos de dados inteiros ou um subconjunto de dados (com filtro opcional), com NRQL no formato de:

    DELETE FROM DATA_TYPE_1, DATA_TYPE_2 (WHERE OPTIONAL_FILTER)

    Copiar

• Regra de atributo de descarte

  • Remover atributo de tipos de dados (com filtro opcional), com NRQL no formato de:

    DELETE dropAttr1, dropAttr2 FROM DATA_TYPE (WHERE OPTIONAL_FILTER)

    Copiar
  • Para esse tipo de regra, você deve passar uma lista não vazia de nomes de atributos brutos na cláusula DELETE .

Para saber mais sobre quais dados são considerados faturáveis ou não, consulte Ingestão de dados.

Escopo de dados das regras da nuvem

Use regras cloud para destino dos seguintes tipos de dados:

• Evento relatado pelo APM

• Evento relatado pelo browser

• Evento relatado em dispositivos móveis

• Evento relatado pelo Sintético

• Evento personalizado (como aqueles gerados pela API do agente do APM ou pela API do evento)

• Log dados (você também pode usar a interface para descartar dados)

• Períodos distributed tracing

• Evento de monitoramento de infraestrutura padrão e evento de integração de infraestrutura . Algumas advertências:

  • Quando você descarta esses dados, os dados brutos são excluídos, mas os eventos agregados SystemSample, ProcessSample, NetworkSample e StorageSample ainda estão disponíveis (para mais informações sobre isso, consulte Redução de dados). Embora ainda disponíveis, esses dados não contam para ingestão e não são faturáveis.
  • Os dados brutos da infraestrutura são usados para alertas, portanto, se você descartar esses dados, não poderá alertá-los. Como os dados agregados ainda estão disponíveis, você ainda poderá ver esses dados em gráficos com intervalos de tempo acima de 59 minutos.

• Dimensional métrica. Algumas advertências:

  • Para métricas geradas pelo serviço evento-to-métrica: as regras do Cloud não funcionarão, mas essas métricas podem ser interrompidas ou podadas ao desabilitar ou reconfigurar a regra evento-to-métrica.
  • dados métricos de fração de tempo não podem ser descartados com regras cloud . Para obter mais informações sobre dados de métrica de fração de tempo APM consulte este documento.

Restrições NRQL

• O limite de comprimento da consulta NRQL é de 4.096 caracteres. Se exceder o comprimento, ocorrerá o erro INVALID_NRQL_TOO_LONG . Se você precisar descartar dados com base em uma consulta mais longa que não pode ser dividida, entre em contato com o suporte da New Relic.
• JOIN e subconsultas não são suportadas.
• Você pode fornecer uma cláusula WHERE para selecionar dados com atributo específico.
• Você não deve usar a tag entidade em uma cláusula WHERE para descartar dados, porque as tags entidade são obtidas em um processo separado e não são atributos dos dados MELT avaliados pela regra cloud do pipeline.
• recursos como LIMIT, TIMESERIES, COMPARE WITH, FACET e outras cláusulas não podem ser usadas.
• SINCE e UNTIL não são suportados. Se você tiver regras específicas de tempo (por exemplo, abandonar tudo até um momento no futuro), use WHERE timestamp < (epoch milliseconds in the future).
• Você não pode usar SINCE para descartar dados históricos. As regras da nuvem só se aplicam aos dados relatados após a criação da regra. Se precisar excluir dados que já foram relatados, consulte Excluir dados existentes ou entre em contato com o suporte da New Relic.

Histórico de regras de auditoria

Para ver quem criou e excluiu regras cloud , consulte os logs de auditoria da sua conta. O lista de endpoint também inclui o ID de usuário da pessoa que criou a regra.

Cuidados ao descartar dados

As regras da nuvem se aplicam a cada ponto de dados de forma independente. Por exemplo, vejamos as três regras de descarte de dados a seguir:

1. DELETE FROM MyEvent WHERE myAttr not in ('staging')
2. DELETE FROM MyEvent WHERE myAttr not in ('production')
3. DELETE FROM MyEvent WHERE myAttr in ('development')

Essas três regras são aplicadas independentemente a cada ponto de dados; em resumo, todos os eventos MyEvent contendo myAttr com qualquer valor serão descartados:

• myAttr: 'staging' -> corresponde à regra 2
• myAttr: 'production' -> corresponde à regra 1
• myAttr: 'development' -> corresponde às regras 1, 2 e 3
• myAttr: 'uuid-random-string' -> regras de correspondência 1 e 2

A New Relic não pode garantir que esta funcionalidade resolverá completamente suas preocupações com divulgação de dados. A New Relic não analisa nem monitora a eficácia das regras que você desenvolve. Sempre teste e teste novamente sua consulta e, depois que a regra de descarte for criada, certifique-se de que ela funciona conforme o esperado.

A criação de regras sobre dados confidenciais pode vazar informações sobre os tipos de dados que você mantém, incluindo o formato dos seus dados ou sistemas (por exemplo, por meio de referência a endereços de e-mail ou números de cartão de crédito específicos). As regras que você cria, incluindo todas as informações nessas regras, podem ser visualizadas e editadas por qualquer usuário com as permissões de controle de acesso baseadas em função relevantes.

Apenas novos dados serão descartados. Os dados existentes não podem ser editados ou excluídos.

Gerenciando regras cloud

Para criar e editar regras, você pode usar a interface Controle de Pipeline ou o NerdGraph API Explorer (one.newrelic.com > Apps > NerdGraph API Explorer).

Use case examples

mutation {
  entityManagementCreatePipelineCloudRule(
    pipelineCloudRuleEntity: {
      description: "Event1 and Event2 are unimportant, see ticket DM-1234"
      name: "Drop all data for Event1 and Event2"
      nrql: "DELETE FROM Event1, Event2"
      scope: { id: "your_nr_account_id", type: ACCOUNT }
    }
  ) {
    entity {
      id
      name
      nrql
    }
  }
}

mutation {
  entityManagementCreatePipelineCloudRule(
    pipelineCloudRuleEntity: {
      description: "Drops all data for MyCustomEvent that comes from the LoadGeneratingApp in the dev environment, because there is too much and we don’t look at it"
      name: "Drop MyCustomEvent from LoadGeneratingApp in dev"
      nrql: "DELETE FROM MyCustomEvent WHERE appName='LoadGeneratingApp' AND environment='development'"
      scope: { id: "your_nr_account_id", type: ACCOUNT }
    }
  ) {
    entity {
      id
      name
      nrql
    }
  }
}

mutation {
  entityManagementCreatePipelineCloudRule(
    pipelineCloudRuleEntity: {
      description: "Removes the user name and email fields from MyCustomEvent"
      name: "Drop username and email from MyCustomEvent"
      nrql: "DELETE userName, userEmail FROM MyCustomEvent"
      scope: { id: "your_nr_account_id", type: ACCOUNT }
    }
  ) {
    entity {
      id
      name
      nrql
    }
  }
}

Verifique se sua regra funciona

Depois de criar uma regra cloud , talvez você queira verificar se ela está funcionando conforme o esperado. A regra deve entrar em vigor rapidamente após um registro bem-sucedido, então tente executar uma versão TIMESERIES da consulta que você registrou para ver se os dados desaparecem.

Observação: os dados de séries temporais são renderizados com o tempo do evento (não o tempo de processamento) como eixo x. Como New Relic aceita dados com um timestamp de até vinte e quatro horas no futuro, você poderá ver alguns dados que foram enviados ao New Relic antes da regra ser criada, mas com um timestamp do evento anterior à criação da regra.

DELETE FROM MyEvent WHERE foo = bar

SELECT count(*) FROM MyEvent WHERE foo = bar TIMESERIES

DELETE dropAttr1, dropAttr2 FROM MyEvent WHERE foo = bar

SELECT count(dropAttr1), count(dropAttr2) FROM MyEvent WHERE foo = bar TIMESERIES

NerdGraph examples

Criar regras cloud

Soltar dados:

mutation {
  entityManagementCreatePipelineCloudRule(
    pipelineCloudRuleEntity: {
      description: "Since we only care about MyEvent in staging and production, let's drop all MyEvent data in the test environment"
      name: "Drop MyEvent in test environment"
      nrql: "DELETE FROM MyEvent WHERE environment = 'test'"
      scope: { id: "your_nr_account_id", type: ACCOUNT }
    }
  ) {
    entity {
      id
      name
      nrql
    }
  }
}

Atributo de queda:

mutation {
  entityManagementCreatePipelineCloudRule(
    pipelineCloudRuleEntity: {
      description: "We don't care about jvmId and targetAttr in the test environment, let's drop those attributes"
      name: "Drop jvmId and targetAttr from MyEvent in test environment"
      nrql: "DELETE jvmId, targetAttr FROM MyEvent WHERE environment = 'test'"
      scope: { id: "your_nr_account_id", type: ACCOUNT }
    }
  ) {
    entity {
      id
      name
      nrql
    }
  }
}

Update a cloud rule

You can modify existing cloud rules to adjust their filtering criteria, data types, or deployment scope.

To update an existing Cloud rule, you'll use the updatePipelineCloudRule mutation. This allows you to change the rule's name, description, and, crucially, its NRQL.

Identify the rule

You'll need the unique entity ID of the cloud rule you wish to update. You can find this ID by querying your rules using NerdGraph. For example:

actor { 
  entitySearch(
    query: "type = 'PIPELINE_CLOUD_RULE'"
    ) 
    { 
      results { 
        entities { 
          id 
          name 
        } 
      } 
    } 
}

Construct your mutation:

Use the updatePipelineCloudRule mutation, providing the rule's id and a pipelineCloudRuleEntity object containing the fields you want to change.

• id: The entity ID of the cloud rule you identified in step 1.

• pipelineCloudRuleEntity: An object containing the updated details. You can provide any or all of the below fields:

  • nrql: The updated NRQL query that defines what data or attributes to drop. This should be a DELETE NRQL query (for example, DELETE FROM MyEvent or DELETE attribute FROM MyEvent).

  • name: The new name for your rule (optional).

  • description: The new description for your rule (optional).

Suppose you have an existing rule that drops dropAttr1 from MyEventToDrop eventType. If you want to change it to drop dropAttr2 instead, call the following mutation:

mutation UpdatePipelineCloudRule {
  updatePipelineCloudRule(
    id: "MTAyNTY1MHxOR0VQfFBJUEVMSU5FX0NMT1VEX1JVTEV8MDE5ODgwOTUtMmZjNC03MTQ3LTkxMjQtZDk3YjhiY2Y4NGNj" # Replace with your rule's actual entity ID
    pipelineCloudRuleEntity: {
      description: "Since we do not need dropAttr2 ingested we would drop this attribute."
      name: "Update for Dropping dropAttr2 from MyEventToDrop"
      nrql: "DELETE dropAttr2 FROM MyEventToDrop"
    }
  ) {
    entity {
      id
      type
      name
      description
      nrql
    }
  }
}

Verify the update

• Check the API response: The entity object in the response will reflect the updated name, description, and NRQL.

• Monitor your data: Send new data that would be affected by the rule and confirm that the dropping behavior has changed as expected. For example, if you changed from dropping attr1 to attr2, ensure attr1 is now ingested and attr2 is no longer appearing.

Excluir uma regra cloud

mutation {
  entityManagementDelete(
    id: "MTAyNTY1MHxOR0VQfFBJUEVMSU5FX0NMT1VEX1JVTEV8MDE5NWI0NDYtNjk5My03NGE5LWEyYjktMzBjMzQ1ODM0NTUz"
  ) {
    id
  }
}

Ver regras cloud

Obtenha uma única regra cloud :

{
  actor {
    entityManagement {
      entity(
        id: "MTAyNTY1MHxOR0VQfFBJUEVMSU5FX0NMT1VEX1JVTEV8MDE5NWI0M2UtYmFhNy03NDk3LWI0N2ItNjUyMmEzZDFmZTFi"
      ) {
        id
        ... on EntityManagementPipelineCloudRuleEntity {
          id
          name
          description
          nrql
          metadata {
            createdBy {
              id
            }
            createdAt
          }
        }
      }
    }
  }
}

Listar todas as regras cloud :

{
  actor {
    entityManagement {
      entitySearch(query: "type = 'PIPELINE_CLOUD_RULE'") {
        entities {
          id
          type
          ... on EntityManagementPipelineCloudRuleEntity {
            id
            name
            nrql
          }
          metadata {
            createdBy {
              id
            }
          }
        }
      }
    }
  }
}

Evento e atributo não dropáveis

Você não pode descartar o seguinte evento e atributo usando regras cloud :

Eliminar atributo em rollups de métricas dimensionais

Métrica dimensional métrica agregada em rollups para armazenamento de longo prazo e como forma de otimizar consultas de longo prazo. Os limites de cardinalidade métrica são aplicados a esses dados.

Você pode usar este recurso para decidir qual atributo você não precisa para armazenamento e consulta de longo prazo, mas gostaria de manter para consultas em tempo real.

Por exemplo, adicionar containerId como um atributo pode ser útil para resolução de problemas em tempo real ou análise recente, mas pode não ser necessário ao consultar tendências maiores durante longos períodos de tempo. Devido ao quão único algo como containerId pode ser, ele pode levá-lo rapidamente aos limites de cardinalidade métrica que, quando atingido, interrompe a síntese de rollups para o restante daquele dia UTC.

Esse recurso também permite manter a cardinalidade alta atributo nos dados brutos e removê-la dos rollups, o que lhe dá mais controle sobre a rapidez com que você se aproxima dos limites de cardinalidade.

Uso

Drop attributes from dimensional metrics rollups (com filtro opcional). Isso usa NRQL do formato:

DELETE dropAttr1, dropAttr2 FROM MetricAggregate (WHERE OPTIONAL_FILTER)

Aqui está um exemplo de solicitação do NerdGraph:

mutation {
  entityManagementCreatePipelineCloudRule(
    pipelineCloudRuleEntity: {
      description: "We don't care about targetAttr in the test environment in dimensional metric rolloups, let's drop those attributes"
      name: "Drop targetAttr from Metric aggregate rollups in test environment"
      nrql: "DELETE targetAttr FROM MetricAggregate WHERE environment = 'test'"
      scope: { id: "your_nr_account_id", type: ACCOUNT }
    }
  ) {
    entity {
      id
      name
      nrql
    }
  }
}

Para verificar se está funcionando, aguarde de 3 a 5 minutos para que a regra seja escolhida e os dados agregados sejam gerados. Então, assumindo que o NRQL de exemplo acima é sua regra cloud de controle de pipeline, execute a seguinte consulta:

SELECT count(targetAttr) FROM Metric WHERE metricName = 'some.metric' TIMESERIES SINCE 2 hours ago
SELECT count(targetAttr) FROM MetricRaw WHERE metricName = 'some.metric' TIMESERIES SINCE 2 hours ago

A primeira consulta recupera rollups métricos e deve cair para 0, pois containerId foi descartado de acordo com a nova regra de descarte. A segunda consulta recupera dados brutos métricos usando o tipo de evento MetricRaw e deve continuar estável, pois os dados brutos não são afetados pela nova regra de descarte. Para mais informações sobre como ver o impacto que isso terá na sua cardinalidade, confira Entender e consultar cardinalidade alta métrica.

Restrições

Todas as restrições que se aplicam às regras de descarte de atributos se aplicam às regras de descarte de atributos de agregação métrica dimensional com a restrição adicional de que você só pode destino o tipo de dados MetricAggregate . Eles também não funcionam em Metric dados de consulta de segmentação criados por um evento para regra métrica ou em Metric dados de consulta de segmentação da fração de tempo.

Saber mais

Recomendações para aprender mais:

• Noções básicas e terminologia do NerdGraph
• Noções básicas de NRQL
• Navegue pelo Fórum de Suporte para discussões da comunidade sobre regras cloud .
• Para um mergulho profundo na gestão da ingestão de dados para uma organização complexa, consulte a governação da ingestão de dados.