Simple Log Service:Coleta de logs com timestamps em precisão de nanossegundos

Etapa 1: Crie um projeto e um LogStore

Se você já possui um projeto e um LogStore, pule para Etapa 2: Configure um grupo de máquinas e instale o LoongCollector.

Caso contrário, crie os recursos para gerenciar e armazenar seus logs:

1. Faça login no console do Simple Log Service.

2. Clique em Create Project e configure os seguintes parâmetros:

   • Region: Selecione a região com base na origem dos seus logs. A região não pode ser alterada após a criação do projeto.

   • Project Name: Insira um nome globalmente exclusivo no Alibaba Cloud. O nome não pode ser alterado após a criação do projeto.

3. Mantenha as configurações padrão para os outros parâmetros e clique em Create. Para mais informações, consulte Manage projects.

4. Clique no nome do projeto para acessá-lo.

5. No painel de navegação à esquerda, escolha Log Storage e clique em +.

6. Na página Create LogStore, configure os seguintes parâmetros:

   • Logstore Name: Defina um nome exclusivo dentro do projeto. O nome não pode ser alterado após a criação do LogStore.

   • Logstore Type: Selecione Standard ou Query com base na comparação de especificações.

   • Billing Mode:

     • Pay-by-feature: A cobrança é feita separadamente para cada recurso, como armazenamento, índices e operações de leitura e escrita. Este modo é adequado para cenários de pequena escala ou quando o uso de recursos ainda é incerto.

     • Pay-by-ingested-data: A cobrança ocorre apenas sobre os dados brutos ingeridos. Este modo inclui um período gratuito de armazenamento de 30 dias e recursos gratuitos como transformação e entrega de dados. O modelo de custo é simples, sendo ideal para cenários onde o período de retenção é próximo de 30 dias ou o pipeline de processamento de dados é complexo.

   • Data Retention Period: Defina o número de dias para reter os logs. Valores válidos: 1 a 3.650. O valor 3.650 indica retenção permanente. Valor padrão: 30.

7. Mantenha as configurações padrão para os outros parâmetros e clique em OK. Para mais informações, consulte Manage LogStores.

Etapa 2: Configure um grupo de máquinas e instale o LoongCollector

Instale o LoongCollector no seu servidor e adicione-o a um grupo de máquinas. Este tópico usa como exemplo uma instância ECS com o LoongCollector instalado, onde a instância ECS e o projeto SLS pertencem à mesma conta e região do Alibaba Cloud. Se a instância ECS e o projeto não pertencerem à mesma conta ou região, ou se você utilizar um servidor autogerenciado, consulte Install LoongCollector para instalar o coletor manualmente.

| Clique no projeto desejado. Na página LogStores :

• Clique em antes do nome do LogStore alvo para expandi-lo.

• Clique em ao lado de Data Collection.

• Na caixa de diálogo exibida, selecione um modelo de log de texto. Este tópico utiliza o modelo Single Line - Text Logs como exemplo. Clique em Integrate Now. Todos os modelos de log de texto diferem apenas no processador de análise. O restante do processo de configuração é idêntico e todas as configurações podem ser modificadas posteriormente.

Etapas de configuração:

1. Na página Machine Group Configurations, configure os seguintes parâmetros:

   • Scenario: Servers

   • Installation Environment: ECS

2. Configure o grupo de máquinas: Selecione a ação correspondente ao status de instalação do LoongCollector e ao status do grupo de máquinas do servidor alvo:

   • Se o LoongCollector já estiver instalado e o servidor já pertencer a um grupo de máquinas, selecione o grupo na lista Source Machine Group e adicione-o à lista Applied Machine Group. Não é necessário criar o grupo novamente.

   • Se o LoongCollector não estiver instalado, clique em Create Machine Group: As etapas a seguir orientam você na instalação automática do LoongCollector e na criação de um novo grupo de máquinas.

     1. O sistema lista automaticamente as instâncias ECS residentes na mesma região do projeto. Selecione uma ou mais instâncias das quais deseja coletar logs.

     2. Clique em Install and Create Machine Group. O sistema instala automaticamente o LoongCollector nas instâncias ECS selecionadas.

     3. Configure o Name do grupo de máquinas e clique em OK. Se a instalação falhar ou permanecer no estado de espera, verifique se a instância ECS reside na mesma região do projeto.

3. Para adicionar um servidor com o LoongCollector já instalado a um grupo de máquinas existente, consulte o tópico de FAQ How do I add a server to an existing machine group?

Etapa 3: Crie uma configuração de coleta

Configuração via console: acesse a página Logtail Configurations para definir as regras de coleta e processamento de logs.

1. Ative o suporte à precisão de nanossegundos Defina a origem do log e as regras de coleta, e ative o suporte à precisão de nanossegundos.

Global Configurations:

• Configuration Name: Defina um nome exclusivo dentro do projeto. O nome não pode ser alterado após a criação da configuração.

• Other Global Configurations: Ative a chave Advanced Parameters e insira o seguinte conteúdo JSON para habilitar o suporte à precisão de nanossegundos:

{
  "EnableTimestampNanosecond": true
}

Input Configurations:

• Type: Text Log Collection.

• File Path: O caminho de onde os logs são coletados.

  • Linux: Comece com uma barra (/). Por exemplo, /data/mylogs/**/*.log especifica todos os arquivos com extensão .log no diretório /data/mylogs.

  • Windows: Comece com uma letra de unidade. Por exemplo: C:\Program Files\Intel\**\*.Log.

• Maximum Directory Monitoring Depth: A profundidade máxima de diretório que o curinga ** em File Path pode corresponder. Valor padrão: 0, que monitora apenas o diretório atual.

  2. Configure processadores Como o log de origem está no formato JSON, adicione o processador Data Parsing (JSON Mode) na seção Processing Steps. Este processador separa a string contendo o timestamp em nanossegundos do log bruto e a armazena como um campo independente.

• Adicione uma amostra de log

  Suponha que o arquivo de log contenha registros no seguinte formato, onde o campo asctime contém um timestamp com precisão de nanossegundos.

{
  "asctime": "2023-10-25 23:51:10,199999999",
  "filename": "generate_data.py",
  "levelname": "INFO",
  "lineno": 51,
  "module": "generate_data",
  "message": "{\"no\": 14, \"inner_loop\": 166, \"loop\": 27451, \"uuid\": \"9be98c29-22c7-40a1-b7ed-29ae6c8367af\"}",
  "threadName": "MainThread"
}

• Adicione um processador de análise JSON

  Clique em Add Processor, selecione Native Processor > Data Parsing (JSON Mode) e clique em Confirm.

• Adicione um processador de análise de tempo

  Converta a string de tempo extraída na etapa anterior (campo asctime) em um timestamp padrão em nanossegundos e utilize-a como o tempo do evento do log.

Nome do processador	Recurso principal	Caso de uso
Time Parsing	Análise básica de tempo	Cenários simples com formato fixo.
Time - Strptime	Flexível, suporta ampla variedade de formatos strptime	Recomendado. Recursos abrangentes compatíveis com padrões da indústria.
Time - Go	Usa o formato da biblioteca padrão Go	Cenários onde há familiaridade com Go ou o formato do log corresponde à biblioteca padrão Go.

Time parsing

Clique em Add Processor, selecione Native Processor > Time Parsing e configure os seguintes parâmetros:

• Original Field: O campo original que armazena o tempo antes da análise do log. Neste exemplo, o campo é asctime.

• Time Format: Defina o formato de tempo correspondente ao conteúdo do campo de tempo nos seus logs. Neste exemplo, o formato é %Y-%m-%d %H:%M:%S,%f, onde %f representa a parte fracionária de um segundo e suporta precisão de até nanossegundos.

Nota

A string de formato de tempo deve ser idêntica ao formato de tempo no log bruto, incluindo o separador entre os segundos e os nanossegundos, como , ou .. Caso contrário, os logs não serão analisados corretamente.

• Time Zone: Selecione o fuso horário do campo de tempo nos seus logs. Por padrão, o fuso horário do servidor é utilizado.

Time - strptime

Clique em Add Processor, selecione Extended Processor > Time - Strptime e configure os seguintes parâmetros:

• Original Field: O campo original que armazena o tempo antes da análise do log. Neste exemplo, o campo é asctime.

• Original Time Format: Defina o formato de tempo correspondente ao conteúdo do campo de tempo nos seus logs. Neste exemplo, o formato é %Y-%m-%d %H:%M:%S,%f, onde %f representa a parte fracionária de um segundo e suporta precisão de até nanossegundos.

Nota

A string de formato de tempo deve ser idêntica ao formato de tempo no log bruto, incluindo o separador entre os segundos e os nanossegundos, como , ou .. Caso contrário, os logs não serão analisados corretamente.

Time - Go

Clique em Add Processor, selecione Extended Processor > Time - Go e configure os seguintes parâmetros:

• Original Time Field: O campo original que armazena o tempo antes da análise do log. Neste exemplo, o campo é asctime.

• Original Time Format: Defina o formato de tempo correspondente ao campo de tempo no log bruto. Escreva o formato com base na especificação de formato de tempo do Go. O modelo de formatação de tempo é a data de nascimento da linguagem Go, 2006-01-02 15:04:05 -0700 MST. O formato de tempo para este exemplo é 2006-01-02 15:04:05,999999999.

Nota

A string de formato de tempo deve ser idêntica ao formato de tempo no log bruto, incluindo o separador entre os segundos e os nanossegundos, como , ou .. Caso contrário, os logs não serão analisados corretamente.

• New Time Field: O campo de destino que armazena o tempo após a análise do log. Neste exemplo, o campo é result_asctime.

• New Time Format: O formato de tempo após a análise do log. Escreva o formato com base na especificação de formato de tempo do Go. Neste exemplo, o formato é 2006-01-02 15:04:05,999999999Z07:00.

3. Configure índices Após concluir a configuração do Logtail, clique em Next. A página Query and Analysis Configurations será exibida:

• O sistema ativa full-text indexing por padrão, o que permite buscar palavras-chave no conteúdo bruto do log.

• Para executar consultas exatas por campo, aguarde até que Preview Data seja carregado na página e clique em Automatic Index Generation. O SLS gera um field index com base na primeira entrada dos dados de visualização.

  Após concluir a configuração, clique em Next para finalizar a configuração de todo o processo de coleta.

Configuração via CRD (cenários Kubernetes) Em um cluster ACK ou Kubernetes autogerenciado, configure a coleta de timestamps com precisão de nanossegundos usando um AliyunLog CRD. Salve o seguinte conteúdo YAML em um arquivo e execute kubectl apply -f <filename> para aplicar a configuração. Os exemplos abaixo mostram as configurações para os três processadores.

Time parsing

apiVersion: telemetry.alibabacloud.com/v1alpha1
kind: ClusterAliyunPipelineConfig
metadata:
  name: ${your-config-name}
spec:
  config:
    aggregators: []
    global:
      EnableTimestampNanosecond: true
    inputs:
      - Type: input_file
        FilePaths:
          - /test/sls/json_nano.log
        MaxDirSearchDepth: 0
        FileEncoding: utf8
        EnableContainerDiscovery: true
    processors:
      - Type: processor_parse_json_native
        SourceKey: content
      - Type: processor_parse_timestamp_native
        SourceKey: asctime
        SourceFormat: '%Y-%m-%d %H:%M:%S,%f'
    flushers:
      - Type: flusher_sls
        Logstore: ${your-logstore-name}
    sample: |-
      {
        "asctime": "2025-11-03 15:39:14,229939478",
        "filename": "log_generator.sh",
        "levelname": "INFO",
        "lineno": 204,
        "module": "log_generator",
        "message": "{\"no\": 45, \"inner_loop\": 15, \"loop\": 1697, \"uuid\": \"80366fca-a57d-b65a-be07-2ac1173505d9\"}",
        "threadName": "MainThread"
      }
  project:
    name: ${your-project-name}
  logstores:
    - name: ${your-logstore-name}

Time - strptime

apiVersion: telemetry.alibabacloud.com/v1alpha1
kind: ClusterAliyunPipelineConfig
metadata:
  name: ${your-config-name}
spec:
  config:
    aggregators: []
    global:
      EnableTimestampNanosecond: true
    inputs:
      - Type: input_file
        FilePaths:
          - /test/sls/json_nano.log
        MaxDirSearchDepth: 0
        FileEncoding: utf8
        EnableContainerDiscovery: true
    processors:
      - Type: processor_parse_json_native
        SourceKey: content
      - Type: processor_strptime
        SourceKey: asctime
        Format: '%Y-%m-%d %H:%M:%S,%f'
        KeepSource: true
        AlarmIfFail: true
        AdjustUTCOffset: false
    flushers:
      - Type: flusher_sls
        Logstore: ${your-logstore-name}
    sample: |-
      {
        "asctime": "2025-11-03 15:39:14,229939478",
        "filename": "log_generator.sh",
        "levelname": "INFO",
        "lineno": 204,
        "module": "log_generator",
        "message": "{\"no\": 45, \"inner_loop\": 15, \"loop\": 1697, \"uuid\": \"80366fca-a57d-b65a-be07-2ac1173505d9\"}",
        "threadName": "MainThread"
      }
  project:
    name: ${your-project-name}
  logstores:
    - name: ${your-logstore-name}

Time - Go

apiVersion: telemetry.alibabacloud.com/v1alpha1
kind: ClusterAliyunPipelineConfig
metadata:
  name: ${your-config-name}
spec:
  config:
    aggregators: []
    global:
      EnableTimestampNanosecond: true
    inputs:
      - Type: input_file
        FilePaths:
          - /test/sls/json_nano.log
        MaxDirSearchDepth: 0
        FileEncoding: utf8
        EnableContainerDiscovery: true
    processors:
      - Type: processor_parse_json_native
        SourceKey: content
      - Type: processor_gotime
        SourceKey: asctime
        SourceFormat: '2006-01-02 15:04:05,999999999'
        DestKey: result_asctime
        DestFormat: '2006-01-02 15:04:05,999999999Z07:00'
        SetTime: true
        KeepSource: true
        NoKeyError: true
        AlarmIfFail: true
    flushers:
      - Type: flusher_sls
        Logstore: ${your-logstore-name}
    sample: |-
      {
        "asctime": "2025-11-03 15:39:14,229939478",
        "filename": "log_generator.sh",
        "levelname": "INFO",
        "lineno": 204,
        "module": "log_generator",
        "message": "{\"no\": 45, \"inner_loop\": 15, \"loop\": 1697, \"uuid\": \"80366fca-a57d-b65a-be07-2ac1173505d9\"}",
        "threadName": "MainThread"
      }
  project:
    name: ${your-project-name}
  logstores:
    - name: ${your-logstore-name}

Após aplicar a configuração CRD, verifique se a configuração de coleta está efetiva checando o LogStore quanto à chegada de logs com timestamps em precisão de nanossegundos.

Etapa 4: Verifique os resultados

Após concluir a configuração, aguarde alguns instantes para que novos dados de log sejam coletados no LogStore.

Na página de consulta e análise do SLS, visualize os logs coletados. O console otimiza automaticamente a exibição com base nas informações de tempo de alta precisão e mostra o tempo no formato de milissegundos, microssegundos ou nanossegundos.

Nos resultados da consulta de log, os timestamps aparecem em um formato como 2025-11-03 17:34:40.747598929.

Para verificar se a precisão de nanossegundos está funcionando corretamente, execute uma consulta para checar o campo __time_ns_part__:

* | SELECT __time__, __time_ns_part__, * FROM log WHERE __time_ns_part__ > 0 ORDER BY __time__, __time_ns_part__ LIMIT 10

Se a consulta retornar resultados com valores de __time_ns_part__ na faixa de 0 a 999.999.999, a precisão de nanossegundos está ativada e funcionando corretamente. Se o campo __time_ns_part__ estiver vazio ou contiver apenas zeros, revise sua configuração de coleta para verificar se:

• A chave Advanced Parameters está ativada e contém { "EnableTimestampNanosecond": true }.

• O processador de análise de tempo está configurado com o formato de tempo correto correspondente aos timestamps do seu log bruto.

• A versão do Logtail no seu servidor é 1.8.0 ou posterior.

Perguntas frequentes

Por que os timestamps em nanossegundos nos logs coletados não são analisados corretamente?

Após configurar a coleta, o tempo de alta precisão não é extraído conforme o esperado.

O tempo do índice no visualizador de logs é 10-26 00:30:39, mas o asctime do registro de log é 2023-10-26 00:30:10,199999999. Os dois valores não coincidem, indicando que o tempo de alta precisão não foi extraído corretamente. Os detalhes do registro de log são os seguintes:

__file_offset__  xxx
__tag__  xxx
asctime: 2023-10-26 00:30:10,199999999
filename: xxx
levelname: INFO
lineno: 51
message: {"no": 14, "inner_loop": 166, "loop": 27451, "uuid": "9be98c29-22c7-40a1-b7ed-29ae6c8367af"}
module: generate_data
threadName: MainThread

Causa

O modo de processador suporta %f, mas o formato de tempo deve ser idêntico ao conteúdo do tempo de origem.

Solução

1. Faça login no servidor LoongCollector (Logtail) e verifique os logs. Você encontrará um grande número de logs de exceção STRPTIME_PARSE_ALARM.

   tail -f /usr/local/ilogtail/logtail_plugin.LOG
   2023-10-26 00:30:39 [WRN] [strptime.go:164] [processLog] [##1.0##xxxx,xxx]    AlarmType:STRPTIME_PARSE_ALARM    strptime(2023-10-26 00:30:10,199999999, %Y-%m-%d %H:%M:%S %f) failed: 0001-01-01 00:00:00 +0000 UTC, <nil>

2. Modifique o formato de análise de log do processador.

   No log bruto, o tempo é 2023-10-26 00:30:10,199999999, e o separador entre os segundos e o tempo de alta precisão (milissegundos neste caso) é uma vírgula (,). No formato de análise %Y-%m-%d %H:%M:%S %f, o separador entre os segundos e o tempo de alta precisão é um espaço. Para corrigir o problema, altere o formato de conversão de tempo na configuração de coleta para %Y-%m-%d %H:%M:%S,%f.

Faturamento e limitações

• Impacto no custo: O campo __time_ns_part__ é armazenado como parte do conteúdo do log, o que aumenta o uso de armazenamento dos logs brutos. O incremento de custo é proporcional ao volume de logs. Avalie o custo de armazenamento com base na sua taxa real de ingestão de logs e no período de retenção.

• Limitações de ambiente: Este recurso tem suporte apenas no Logtail 1.8.0 ou posterior no Linux. A configuração não surte efeito no Windows.

Referências

• Download logs

• Search syntax and functions

• Overview of log query and analysis

Apêndice 1: Formatos comuns de tempo em logs

Em servidores Linux, o Logtail suporta todos os formatos de tempo fornecidos pela função strftime. Qualquer string de tempo de log que a função strftime possa formatar pode ser analisada e utilizada pelo Logtail.

Formato de tempo	Descrição	Exemplo
%a	Nome abreviado do dia da semana.	Fri
%A	Nome completo do dia da semana.	Friday
%b	Nome abreviado do mês.	Jan
%B	Nome completo do mês.	January
%d	Dia do mês, em decimal. Valores válidos: 01 a 31.	07, 31
%f	A parte fracionária de um segundo (milissegundos, microssegundos ou nanossegundos)	123456789
%h	Nome abreviado do mês. Equivalente a %b.	Jan
%H	Hora, no formato de 24 horas.	22
%I	Hora, no formato de 12 horas.	11
%m	Mês, em decimal. Valores válidos: 01 a 12.	08
%M	Minuto, em decimal. Valores válidos: 00 a 59.	59
%n	Uma quebra de linha.	Quebra de linha
%p	AM ou PM.	AM, PM
%r	Tempo no formato de 12 horas. Equivalente a %I:%M:%S %p.	11:59:59 AM
%R	Hora e minuto. Equivalente a %H:%M.	23:59
%S	Segundo, em decimal. Valores válidos: 00 a 59.	59
%t	Um caractere de tabulação.	N/A
%y	Ano sem o século, em decimal. Valores válidos: 00 a 99.	04, 98
%Y	Ano, em decimal.	2004, 1998
%C	Século, em decimal. Valores válidos: 00 a 99.	16
%e	Dia do mês, em decimal. Valores válidos: 1 a 31. Um espaço inicial é necessário para valores de um único dígito.	7, 31
%j	Dia do ano, em decimal. Valores válidos: 001 a 366.	365
%u	Dia da semana, em decimal, onde 1 indica segunda-feira. Valores válidos: 1 a 7.	2
%U	Semana do ano, onde domingo é o primeiro dia da semana. Valores válidos: 00 a 53.	23
%V	Semana do ano, onde segunda-feira é o primeiro dia da semana. Valores válidos: 01 a 53. Se a primeira semana de janeiro tiver quatro ou mais dias, ela é a semana 1. Caso contrário, a próxima semana é a semana 1.	24
%w	Dia da semana, em decimal, onde 0 indica domingo. Valores válidos: 0 a 6.	5
%W	Semana do ano, onde segunda-feira é o primeiro dia da semana. Valores válidos: 00 a 53.	23
%c	A data e hora padrão.	Tue Nov 20 14:12:58 2020
%x	A data padrão, sem a hora.	Tue Nov 20 2020
%X	A hora padrão, sem a data.	11:59:59
%s	Um timestamp Unix.	1476187251

Exemplos de formato de tempo A tabela a seguir lista padrões de tempo comuns, exemplos e as expressões de tempo correspondentes.

Exemplo	Expressão de tempo	Padrão de tempo
2017-12-11 15:05:07	%Y-%m-%d %H:%M:%S	Personalizado
[2017-12-11 15:05:07.012]	[%Y-%m-%d %H:%M:%S.%f]	Personalizado
2017-12-11 15:05:07.123	%Y-%m-%d %H:%M:%S.%f	Personalizado
02 Jan 06 15:04 MST	%d %b %y %H:%M %Z	RFC822
02 Jan 06 15:04 -0700	%d %b %y %H:%M %z	RFC822Z
Monday, 02-Jan-06 15:04:05 MST	%A, %d-%b-%y %H:%M:%S %Z	RFC850
Mon, 02 Jan 2006 15:04:05 MST	%a, %d %b %Y %H:%M:%S %Z	RFC1123
2006-01-02T15:04:05Z07:00	%Y-%m-%dT%H:%M:%S%z	RFC3339
2006-01-02T15:04:05.999999999Z07:00	%Y-%m-%dT%H:%M:%S.%f%z	RFC3339Nano
1637843406	%s	Personalizado
1637843406123	%s	Personalizado (Simple Log Service (SLS) processa os dados com precisão de segundos)

Apêndice 2: Formatos de tempo Go

O bloco de código a seguir lista os formatos oficiais de tempo Go:

const (
    Layout      = "01/02 03:04:05PM '06 -0700" // The reference time, in numerical order.
    ANSIC       = "Mon Jan _2 15:04:05 2006"
    UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
    RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
    RFC822      = "02 Jan 06 15:04 MST"
    RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
    RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
    RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
    RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
    RFC3339     = "2006-01-02T15:04:05Z07:00"
    RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
    Kitchen     = "3:04PM"// Handy time stamps.
    Stamp      = "Jan _2 15:04:05"
    StampMilli = "Jan _2 15:04:05.000"
    StampMicro = "Jan _2 15:04:05.000000"
    StampNano  = "Jan _2 15:04:05.000000000"
)