O Log parsing transforma dados de log não estruturados em atributos pesquisáveis que você pode usar para obter insights mais profundos dos seus logs. Esses atributos permitem filtrar, facetar e criar alertas sobre seus dados com precisão.
Escolha sua estratégia de parsing
Decida se deseja analisar os dados no momento da ingestão ou ao executar uma consulta:
Tipo de análise
Descrição
Melhor para
Parsing em tempo de consulta
Cria atributos temporários usando NRQL que existem apenas durante a execução da consulta. Ideal para análise instantânea de dados existentes sem esperar que novos logs cheguem. Saiba mais sobre análise em tempo de consulta.
Solução de problemas e investigações ad hoc
Análise exploratória em pequenos conjuntos de dados
Investigações pontuais
Extraindo atributos de logs já armazenados no NRDB
Análise em tempo de ingestão
Cria atributos permanentes armazenados no NRDB. Duas maneiras de criar regras de parsing em tempo de ingestão:
Regras de parsing integradas: Padrões pré-configurados para fontes de log comuns (Apache, NGINX, CloudFront, MongoDB, etc.). Basta adicionar um atributo logtype ao encaminhar logs. Consulte a lista completa de regras integradas.
Regras de parsing personalizadas: Quando seus logs são específicos da sua aplicação, as regras de parsing personalizadas permitem definir exatamente quais campos são importantes para o seu negócio.
No Code Log Parsing: Detecta padrões em seus logs de amostra. Melhor para usuários que desejam apontar e clicar para extrair campos.
Grok/Regex: personalizado Entrada manual de código para formatos de log altamente complexos.
Altos volumes de logs
Atributos analisados necessários para alertas, dashboards e monitoramento contínuo
Você também pode criar, consultar e gerenciar suas regras de análise de log usando NerdGraph, nossa API GraphQL. Uma ferramenta útil para isso é nosso Nerdgraph API Explorer. Para obter mais informações, consulte nosso tutorial NerdGraph para análise de arquivos.
/ Here's a 5-minute video about log parsing: <Video id="xPWM46yw3bQ" type="youtube" /> /
Como funciona o parsing personalizado em tempo de ingestão
A análise personalizada permite que você defina exatamente como o New Relic estrutura seus logs de entrada. Antes de criar regras, é importante entender as restrições técnicas do pipeline de ingestão.
Análise de log
Como funciona
O que
As regras de análise são altamente direcionadas. Ao criar uma regra, você define:
O campo alvo: A análise é aplicada a um campo específico por vez.
A lógica de correspondência: Use uma cláusula WHERE do NRQL para filtrar exatamente quais logs esta regra deve avaliar.
O método de extração: Você pode usar No Code Log Parsing para uma experiência de detecção de padrões automática e guiada ou escrever manualmente Grok/Regex para estruturas de log altamente personalizadas e complexas.
Quando
A New Relic processa logs em ordem sequencial. Isso afeta quais condições podem ser correspondidas.
A análise ocorre enquanto os dados são ingeridos. Assim que um log é gravado no NRDB, as alterações feitas são permanentes.
Assim que uma regra é salva e ativada, as regras começam a processar os logs recebidos imediatamente.
A análise ocorre antes do enriquecimento de dados (como síntese de entidades), descarte ou particionamento.
Validação
Para garantir que suas regras funcionem antes de afetar os dados ingeridos, você pode pré-visualizar a saída em 10 amostras de log armazenadas recentemente na partição ‘Log’. Estas amostras representam dados recebidos nos últimos 30 minutos, em vez de um fluxo ao vivo em tempo real.
Criar uma regra personalizada
Você pode criar regras de parsing no contexto ao investigar um log. Isso evita a troca de contexto e reduz o Tempo Médio para Detecção (MTTD). Alternativamente, você pode criar regras do zero ao integrar uma nova aplicação ou serviço.
No Code Log Parsing
Use No Code Log Parsing para detectar e extrair campos de seus logs de amostra. A New Relic analisa seus logs de amostra e sugere padrões que você pode configurar.
Para criar uma regra no contexto, acesse one.newrelic.com > Logs e aplique um filtro (ou selecione qualquer entidade que tenha logs, como APM, Browser ou Mobile, e navegue até Logs in Context).
Para criar uma regra sem contexto, vá para one.newrelic.com > Logs sem definir um filtro ou vá para Logs > Parsing e clique em Create a parsing rule.
No processo de criação de regras no contexto:
Clique em um log para abrir Log details
Selecione o atributo de log que você deseja analisar (por exemplo, message)
Clique em Create ingest time parsing rule e forneça um nome para sua regra
Se você aplicou um filtro na interface de Logs antes de criar a regra, uma condição de correspondência é preenchida automaticamente com base nesse filtro.
No fluxo sem contexto, dê um nome à sua regra e defina uma condição de filtro NRQL ou cole um exemplo de log.
Se você definir um filtro de log, clique em Run your query, selecione o campo que deseja analisar e clique em Next.
Se você colar uma amostra de log, você deve definir a cláusula NRQL WHERE para corresponder aos seus logs, selecionar o campo que deseja analisar e clicar em Next.
Revise o Patterns we detected no log de amostra selecionado e a regra que foi criada. Clique em um padrão destacado para visualizar e editar sua configuração.
Observação
Ao nomear atributos, use letras minúsculas com sublinhados. Evite caracteres especiais, exceto sublinhados, e não inicie um nome de atributo com um número.
Para substrings que você deseja evitar analisar e que incluem valores dinâmicos, certifique-se de defini-las como substrings dinâmicas, selecionando e alterando sua configuração para Yes.
Para um controle mais granular sobre os campos a extrair, clique e arraste para destacar o log de amostra.
Você pode interagir com os padrões das seguintes maneiras:
Auto detect patterns: Para detectar padrões em qualquer parte do log de amostra que ainda não esteja realçada, clique e arraste para realçar essa substring e clique em Auto detect patterns. O New Relic encontrará e destacará padrões na parte selecionada. Para uma lista de nomes de padrões Grok suportados, consulte Nomes de padrões Grok suportados.
Select text to parse: Selecione este modo para a experiência guiada de criação de regras. Este modo oferece uma configuração padrão por padrão. Após definir as configurações de padrão, clique em Add pattern to rule para ver a regra atualizada e visualizar a saída.
Se os padrões detectados não forem relevantes ou estiverem extraindo dados indesejados, você pode removê-los da regra criada:
Destaque o padrão indesejado na janela de log de amostra e clique em Remove selected patterns, ou
Clique em um padrão e selecione Remove.
Revise o painel Preview output. Verifique se os logs de amostra mostram uma marca de seleção verde, indicando que correspondem à sua regra e que os campos serão extraídos no momento da ingestão.
Para alterar sua amostra, expanda qualquer log no painel Preview output e clique em Use as sample.
Se você selecionou um log sem correspondência: A amostra selecionada aparecerá na janela de log de amostra, novos padrões serão detectados e uma nova regra será criada.
Se você selecionou um log correspondente: A amostra selecionada será exibida na janela de log de amostra.
Clique em Save rule para ativar imediatamente ou em Save as draft para ativar mais tarde.
Escreva seu próprio personalizado Grok/Regex
Para formatos exclusivos, usuários avançados podem clicar em Write your own rule na página Create a parsing rule para alternar para o editor de código e modificar padrões diretamente no editor de regras.
Ao terminar de editar a regra, clique em Preview para ver a saída de pré-visualização atualizada e clique em Save rule para ativá-la.
Observação
Para alternar para o editor legado, clique em Switch to original editor no canto superior direito da página Create a parsing rule.
Padrões de dados suportados
A New Relic suporta a análise de vários tipos e formatos de dados usando padrões Grok. Os padrões de parsing são especificados usando Grok, um padrão da indústria para parsing de mensagens de log. O Grok é um superconjunto de expressões regulares que adiciona padrões nomeados integrados para serem usados no lugar de expressões regulares complexas literais.
Regras de parsing podem incluir uma combinação de expressões regulares e nomes de padrões Grok em sua string de correspondência. Clique neste link para ver uma lista de padrões Grok suportados e aqui para ver uma lista de tipos Grok suportados.
PATTERN_NAME é um dos padrões Grok suportados. O nome do padrão é apenas um nome amigável que representa uma expressão regular. Eles são exatamente iguais à expressão regular correspondente.
OPTIONAL_EXTRACTED_ATTRIBUTE_NAME, se fornecido, é o nome do atributo que será adicionado à sua mensagem do log com o valor correspondente ao nome do padrão. É equivalente a usar um grupo de captura nomeado usando expressões regulares. Se isso não for fornecido, a regra de análise corresponderá apenas a uma região da sua string, mas não extrairá um atributo com seu valor.
OPTIONAL_TYPE especifica o tipo de valor de atributo a ser extraído. Se omitido, os valores serão extraídos como strings. Por exemplo, para extrair o valor 123 de "File Size: 123" como um número para o atributo file_size, use value: %{INT:file_size:int}.
OPTIONAL_PARAMETER especifica um parâmetro opcional para determinados tipos. Atualmente apenas o tipo datetime recebe um parâmetro. Veja detalhes abaixo.
O campo OPTIONAL_TYPE especifica o tipo de valor de atributo a ser extraído. Se omitido, os valores serão extraídos como strings.
Os tipos suportados são:
Tipo especificado no Grok
Tipo armazenado no banco de dados New Relic
boolean
boolean
byteshortintinteger
integer
long
long
float
float
double
double
string (padrão) text
string
datedatetime
O tempo como long
Por padrão, é interpretado como ISO 8601. Se OPTIONAL_PARAMETER estiver presente, ele especifica a string de padrão de data e horaa ser usada para interpretar o datetime.
Se você tiver log multilinha, esteja ciente de que o padrão GREEDYDATA Grok não corresponde a novas linhas (é equivalente a .*).
Portanto, em vez de usar %{GREEDYDATA:some_attribute} diretamente, você precisará adicionar o sinalizador multilinha na frente dele: (?s)%{GREEDYDATA:some_attribute}
O pipeline de logs do New Relic analisa suas mensagens de log JSON por padrão, mas, às vezes, você tem mensagens de log JSON misturadas com texto simples. Nessa situação, você pode querer analisá-los e, em seguida, filtrar usando os atributos JSON. Se for esse o caso, você pode usar o tipo Grokjson, que analisará o JSON capturado pelo padrão Grok. Este formato baseia-se em 3 partes principais: a sintaxe Grok, o prefixo que você deseja atribuir aos atributos JSON analisados e o jsontipo Grok. Usando o jsontipo Grok, você pode extrair e analisar JSON de logs que não estão formatados corretamente; por exemplo, se seus logs forem prefixados com uma string de data/hora:
Você pode definir a lista de atributos a serem extraídos ou descartados com as opções keepAttributes ou dropAttributes. Por exemplo, com a seguinte expressão Grok:
Se desejar omitir o prefixo my_attribute_prefix e manter apenas o atributo status , você poderá incluir "noPrefix": true e "keepAttributes: ["status"] na configuração.
Se seu JSON tiver escapado, você poderá usar a opção isEscaped para poder analisá-lo. Se o seu JSON tiver sido escapado e depois citado, você também precisará combinar as aspas, conforme mostrado abaixo. Por exemplo, com a seguinte expressão Grok:
Para configurar o tipo jsonGrok, use :json(_CONFIG_):
json({"dropOriginal": true}): elimine o trecho JSON que foi usado na análise. Quando definido como true (valor padrão), a regra de análise eliminará o trecho JSON original. Observe que o atributo JSON permanecerá no campo da mensagem.
json({"dropOriginal": false}): isso mostrará a carga JSON que foi extraída. Quando definido como false, a carga completa somente JSON será exibida em um atributo nomeado em my_attribute_prefix acima. Observe que o atributo JSON permanecerá no campo de mensagem aqui, dando ao usuário 3 visualizações diferentes dos dados JSON. Se o armazenamento de todas as três versões for uma preocupação, é recomendado usar o padrão true aqui.
json({"depth": 62}): níveis de profundidade que você deseja analisar o valor JSON (padrão 62).
json({"keepAttributes": ["attr1", "attr2", ..., "attrN"]}): Especifica qual atributo será extraído do JSON. A lista fornecida não pode estar vazia. Se esta opção de configuração não estiver definida, todos os atributos serão extraídos.
json({"dropAttributes": ["attr1", "attr2", ..., "attrN"]}): Especifica qual atributo será retirado do JSON. Se esta opção de configuração não for definida, nenhum atributo será eliminado.
json({"noPrefix": true}): Defina esta opção como true para remover o prefixo do atributo extraído do JSON.
json({"isEscaped": true}): Defina esta opção como true para analisar o JSON que foi escapado (que normalmente você vê quando o JSON é stringificado, por exemplo {\"key\": \"value\"})
Se o seu sistema envia log de valores separados por vírgula (CSV) e você precisa analisá-los no New Relic, você pode usar o tipo csv Grok, que analisa o CSV capturado pelo padrão Grok. Este formato depende de 3 partes principais: a sintaxe Grok, o prefixo que você gostaria de atribuir ao atributo CSV analisado e o csvtipo Grok. Usando o tipo csvGrok, você pode extrair e analisar CSV do log.
É obrigatório indicar as colunas na configuração do tipo CSV Grok (que deve ser um JSON válido).
Você pode ignorar qualquer coluna definindo "_" (sublinhado) como o nome da coluna para removê-la do objeto resultante.
Opções de configuração opcionais:
Embora a configuração de “colunas” seja obrigatória, é possível alterar a análise do CSV com as seguintes configurações.
dropOriginal: (o padrão é true) Elimine o trecho CSV usado na análise. Quando definida como true (valor padrão), a regra de análise descarta o campo original.
noPrefix: (o padrão é false) Não inclui o nome do campo Grok como prefixo no objeto resultante.
separator: (O padrão é ,) Define o caractere/string que divide cada coluna.
Outro cenário comum são os valores separados por tabulações (TSV), para isso você deve indicar \t como separador, ex. %{GREEDYDATA:log:csv({"columns": ["timestamp", "status", "method", "url", "time", "bytes"], "separator": "\t"})
quoteChar: (O padrão é ") Define o caractere que opcionalmente envolve o conteúdo de uma coluna.
Se o seu sistema enviar log contendo endereços IPv4, New Relic poderá localizá-los geograficamente e enriquecer o evento de log com o atributo especificado. Você pode usar o tipo geoGrok, que encontra a posição de um endereço IP capturado pelo padrão Grok. Este formato pode ser configurado para retornar um ou mais campos relacionados ao endereço, como cidade, país e latitude/longitude do IP.
É obrigatório especificar os campos lookup desejados retornados pela ação geo . É necessário pelo menos um item das opções a seguir.
city: Nome da cidade
countryCode: Abreviatura do país
countryName: Nome de país
latitude: Latitude
longitude: Longitude
postalCode: Código postal, CEP ou similar
region: Abreviatura de estado, província ou território
regionName: Nome do estado, província ou território
O pipeline do New Relic Logs analisa seu mensagem do log por padrão, mas às vezes você tem mensagem do log que são formatados como pares valor principal. Nessa situação, talvez você queira analisá-los e depois filtrar usando o atributo valor principal.
Nesse caso, você pode usar o keyvaluetipo Grok, que analisará os pares chave-valor capturados pelo padrão Grok. Este formato baseia-se em 3 partes principais: a sintaxe Grok, o prefixo que você deseja atribuir aos atributos de chave-valor analisados e o keyvaluetipo Grok. Usando o tipo Grokkeyvalue, você pode extrair e analisar pares chave-valor de logs que não estão formatados corretamente; por exemplo, se seus logs forem prefixados com uma string de data/hora:
"my_attribute_prefix.message": "'This message contains information with spaces",
"my_attribute_prefix.nbn_demo": "INFO",
"my_attribute_prefix.sessionId": "abc123"
Parâmetro Grok Pattern
Você pode personalizar o comportamento de análise com as seguintes opções para se adequar aos seus formatos de log:
delimitador
Descrição: String separando cada par de valor principal.
Valor padrão:, (vírgula)
Substituir: Defina o campo delimiter para alterar esse comportamento.
Separador de Valor-chave
Descrição: String usada para atribuir valores às chaves.
Valor padrão:=
Substituir: Defina o campo keyValueSeparator para uso de separador personalizado.
citaçãoChar
Descrição: Caractere usado para delimitar valores com espaços ou caracteres especiais.
Valor padrão:" (aspas duplas)
Substituir: Defina um caractere personalizado usando quoteChar.
soltarOriginal
Descrição: Descarta a mensagem original do log após a análise. Útil para reduzir o armazenamento de logs.
Valor padrão:true
Substituir: defina dropOriginal como false para manter a mensagem original do log.
sem prefixo
Descrição: Quando true, exclui o nome do campo Grok como um prefixo no objeto resultante.
Valor padrão:false
Substituição: Habilite definindo noPrefix como true.
escapeChar
Descrição: Defina um caractere de escape personalizado para manipular caracteres de log especiais.
Valor padrão: "" (barra invertida)
Substituir: personalizar com escapeChar.
valores de trim
Descrição: Permite o corte de valores que contêm espaços em branco.
Valor padrão:false
Substituir: defina trimValues como true para ativar o corte.
Teclas de ajuste
Descrição: Permite o corte de teclas que contêm espaços em branco.
Valor padrão:true
Substituir: defina trimKeys como true para ativar o corte.
A New Relic suporta os seguintes padrões Grok:
IP
TIMESTAMP_ISO8601
HTTPDATE
TIME
UUID
MONTH
SPACE
DATESTAMP
DATE
COMBINEDAPACHELOG
ISO8601_TIMEZONE
MAC
DATE_EU
TZ
DATE_US
DAY
LOGLEVEL
NUMBER
INT
QUOTEDSTRING
SYSLOGTIMESTAMP
PATH
SYSLOGBASE
COMMONAPACHELOG
IPV6
COMMONMAC
DATESTAMP_OTHER
ISO8601_SECOND
DATESTAMP_EVENTLOG
SYSLOGBASE2
HAPROXYHTTP
RUBY_LOGGER
WINDOWSMAC
WORD
DATA
GREEDYDATA
NOTSPACE
BASE16FLOAT
QS
BASE10NUM
USER
IPORHOST
USERNAME
IPV4
MONTHDAY
YEAR
HOSTNAME
POSINT
URIPATHPARAM
URI
URIPATH
MONTHNUM
NONNEGINT
MINUTE
SECOND
HOUR
URIHOST
URIPROTO
URIPARAM
SYSLOGHOST
BASE16NUM
SYSLOGPROG
HOSPEDAR
HOSTPORT
JAVACLASS
PROG
UNIXPATH
WINPATH
MONTHNUM2
RUBY_LOGLEVEL
SYSLOGFACILITY
CRON_ACTION
HAPROXYCAPTUREDREQUESTHEADERS
HAPROXYCAPTUREDRESPONSEHEADERS
HAPROXYDATE
CISOMAC
Gerenciar regras de análise
Após criar regras de parsing, você pode gerenciá-las a partir de Logs > Parsing. As regras de rascunho estão salvas, mas ainda não ativadas. Você pode ativá-los quando estiver pronto para aplicá-los aos logs de entrada.
Para editar uma regra de parsing:
Na sua lista de regras de parsing, clique no nome da regra ou clique em ... > Edit e faça as alterações necessárias. Para alternar para o editor de código, clique em Write your own rule para escrever ou modificar padrões Grok/Regex diretamente.
Clique em Save rule (ou Save as draft se quiser mantê-lo desativado).
As alterações se aplicam aos logs ingeridos após a atualização. Para ativar, desativar ou excluir uma regra de parsing:
Encontre a regra na sua lista de regras de parsing e clique no menu ....
Escolha uma ação:
Enable: Ativa a regra de rascunho (aplica-se imediatamente aos logs recém-ingeridos)
Disable: Pausa temporariamente a regra ativa
Delete: Remove a regra completamente
Limites
O parsing é computacionalmente intensivo. Para garantir a estabilidade da plataforma, a New Relic impõe o seguinte:
Limite por mensagem: Uma regra tem 100ms para analisar uma única mensagem. Se exceder isso, a análise será interrompida para essa mensagem.
Limite por conta: O tempo total de processamento é limitado por minuto. Se você atingir isso, os logs permanecerão não analisados (armazenados em seu formato original).
Tempo do pipeline: A análise ocorre antes do enriquecimento. Você não pode corresponder uma regra de parsing a um atributo que ainda não foi adicionado (como uma tag adicionada posteriormente no pipeline).
A regra da primeira correspondência: As regras de parsing não são ordenadas. Se várias regras corresponderem a um único log, a New Relic aplica uma aleatoriamente. Certifique-se de que suas cláusulas WHERE do NRQL sejam específicas o suficiente para evitar correspondências sobrepostas.
Dica
Para verificar facilmente se seus limites de taxa foram atingidos, acesse a página do sistema Limitsna interface do New Relic.
Resolução de problemas
Se a análise não estiver funcionando da maneira desejada, pode ser devido a:
Logic: A lógica de correspondência de regras de análise não corresponde ao log desejado.
Timing: Se a sua regra de análise de correspondência destino for um valor que ainda não existe, ela falhará. Isto pode ocorrer se o valor for adicionado posteriormente no pipeline como parte do processo de enriquecimento.
Limits: Há um período fixo de tempo disponível a cada minuto para processar o log por meio de análise, padrões, filtros de eliminação, etc. Se o tempo máximo tiver sido gasto, a análise será ignorada para registros adicionais de eventos de log.