Simple Log Service:Coleta em lote de logs de texto de servidores

Procedimento:

1. Na página Logstores, clique em ao lado do nome do logstore de destino para expandi-lo.

2. Clique em Data Collection > Logtail Configurations. Na aba One-time Logtail Configuration, clique em Add Logtail Configuration.

3. Na caixa de diálogo Quick Data Import, clique em Integrate Now no cartão One-Time File Collection - Host.

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

   • Scenario: Servers

   • Installation Environment: ECS

   • Selecione o grupo de máquinas: Selecione uma ação com base no status do LoongCollector e do grupo de máquinas no servidor de destino:

     • Se o LoongCollector estiver instalado e tiver sido adicionado a um grupo de máquinas, selecione-o na lista Source Machine Group e adicione-o à lista Applied Machine Group. Você não precisa criar um novo.

     • Se o LoongCollector não estiver instalado, clique em Create Machine Group:

       As etapas a seguir descrevem o processo em um clique para instalar o LoongCollector e criar um grupo de máquinas.

       1. O sistema lista automaticamente as instâncias ECS que estão na mesma região do Project. 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. Insira um Name para o grupo de máquinas e clique em OK.

       Nota

       Se a instalação falhar ou permanecer em estado pendente, verifique se a instância ECS está na mesma região do Project.

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

5. Verifique o status do heartbeat: Clique em Next. Quando a seção Heartbeat Status of Machine Group aparecer, verifique o Heartbeat. Se o status for OK, o grupo de máquinas estará conectado corretamente. Clique em Next para prosseguir para a página de configuração do Logtail.

   Se o status for FAIL, o estabelecimento do heartbeat inicial pode levar algum tempo. Aguarde cerca de dois minutos e atualize o status do heartbeat. Se o status ainda for FAIL após a atualização, consulte Machine group heartbeat connection fails para solucionar o problema.

Global Configurations:

• Configuration Name: especifique um nome personalizado para a configuração de coleta. O nome deve ser único no projeto (Project) e não pode ser modificado após a criação. As regras de nomenclatura são as seguintes:

  • Pode conter apenas letras minúsculas, dígitos, hifens (-) e sublinhados (_).

  • Deve começar e terminar com uma letra minúscula ou um dígito.

• Execution Timeout: o padrão é 600s (10 minutos), e o tempo limite pode ser definido de 600 a 604.800 segundos (10 minutos a 7 dias). Caso uma tarefa de coleta exceda esse tempo limite, o sistema a interrompe à força e os dados restantes não são coletados.

  Importante

  Nota sobre atualizações de configuração: ao atualizar uma configuração, o período de validade é redefinido. Para evitar a execução duplicada de tarefas ou o envio inesperado de dados, certifique-se de que o escopo do grupo de máquinas esteja correto e que o tempo de execução da tarefa anterior não tenha excedido o Execution Timeout.

• Force rerun on update: desativado por padrão.

  • Desativado:

    • Ao atualizar parâmetros da configuração de coleta que não sejam Execution Timeout ou Input Configurations, o sistema retoma o progresso atual da coleta em vez de reiniciar a tarefa. Isso garante uma coleta ininterrupta.

    • Se você modificar o Execution Timeout ou as Input Configurations, o sistema executa a tarefa de coleta novamente.

  • Ativado: ao atualizar a configuração de coleta, a tarefa é reiniciada à força. Isso garante que todos os dados sejam processados e enviados de acordo com as configurações mais recentes. Nota: os dados coletados antes da atualização não são excluídos. Para limpar os dados coletados anteriormente, consulte Soft deletion in Simple Log Service.

Input Configurations:

• Type: One-time File Collection (LoongCollector 3.3+ required).

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

  Nota

  O LoongCollector determina a lista de arquivos a serem coletados e seus tamanhos no momento em que recupera a configuração. Ele não coleta novos arquivos nem conteúdos adicionados aos arquivos existentes após esse momento.

  • Linux: o caminho deve começar com uma barra (/). Por exemplo, /data/mylogs/**/*.log coleta todos os arquivos com a extensão .log em todos os subdiretórios de /data/mylogs.

  • Windows: o caminho deve começar com a letra da unidade. Por exemplo, C:\Program Files\Intel\**\*.Log.

• Maximum Directory Monitoring Depth: a profundidade máxima de diretório que o caractere curinga ** no File Path pode corresponder. O valor padrão é 0, o que significa que apenas o diretório atual é monitorado.

Cenário 2: Processamento de logs estruturados

192.168.*.* - - [15/Apr/2025:16:40:00 +0800] "GET /nginx-logo.png HTTP/1.1" 0.000 514 200 368 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.*.* Safari/537.36"

body_bytes_sent: 368
http_referer: -
http_user_agent : Mozi11a/5.0 (Nindows NT 10.0; Win64; x64) AppleMebKit/537.36 (KHTML, like Gecko) Chrome/131.0.x.x Safari/537.36
remote_addr:192.168.*.*
remote_user: -
request_length: 514
request_method: GET
request_time: 0.000
request_uri: /nginx-logo.png
status: 200
time_local: 15/Apr/2025:16:40:00

Procedimento: na área Processor Configurations da página Logtail Configurations:

1. Adicione um plugin de processador: clique em Add Processor e configure um plugin como regex, delimiter, or JSON parsing com base no formato do seu log. Este exemplo usa um log do NGINX e seleciona Native Processor > Data Parsing (NGINX Mode).

2. NGINX Log Configuration: copie toda a definição log_format do arquivo de configuração do seu servidor NGINX (nginx.conf) e cole-a nesta caixa de texto.

   Exemplo:

   log_format main  '$remote_addr - $remote_user [$time_local] "$request" ''$request_time $request_length ''$status $body_bytes_sent "$http_referer" ''"$http_user_agent"';

   Importante

   A definição de formato aqui deve corresponder exatamente ao formato usado para gerar o log no seu servidor. Caso contrário, a análise falha.

3. Parâmetros comuns: os parâmetros a seguir são comuns a vários plugins de processamento de dados e têm a mesma finalidade.

   • Original field: especifica o campo de origem a ser analisado. O padrão é content, que é toda a entrada de log coletada.

   • Retain original field if parsing fails: recomendado. Se o plugin não conseguir analisar um log, por exemplo, devido a uma incompatibilidade de formato, esta opção retém o conteúdo original do log no campo original especificado.

   • Retain original field if parsing succeeds: esta opção retém o conteúdo original do log mesmo após uma análise bem-sucedida.

Procedimento: na área Global Configurations > Other Global Configurations > Log Topic Type, selecione um método de geração de tópico. Os seguintes tipos são suportados:

• Tópico do grupo de máquinas: ao aplicar uma configuração de coleta a vários grupos de máquinas, o LoongCollector usa automaticamente o nome do grupo de máquinas do servidor como valor para o campo __topic__. Isso é útil para categorizar logs por host.

• Custom: use o formato customized://<custom-topic-name>, por exemplo, customized://app-login. Este método é adequado para tópicos estáticos com identificadores de negócios fixos.

• Extração de caminho de arquivo: extrai informações essenciais do caminho completo de um arquivo de log para marcar dinamicamente a origem do log. Isso é útil quando vários usuários ou aplicativos compartilham o mesmo nome de arquivo de log, mas residem em caminhos diferentes. Por exemplo, quando vários usuários ou serviços gravam logs em diretórios de nível superior diferentes, mas usam o mesmo caminho de subdiretório e nome de arquivo, não é possível distinguir a origem apenas pelo nome do arquivo:

  /data/logs
  ├── userA
  │   └── serviceA
  │       └── service.log
  ├── userB
  │   └── serviceA
  │       └── service.log
  └── userC
      └── serviceA
          └── service.log

  Nesse caso, você pode configurar a extração de caminho de arquivo e usar uma expressão regular para extrair informações essenciais do caminho completo. O resultado correspondente é então enviado para o Logstore como o tópico do log.

  Regras de extração de caminho de arquivo

  Ao configurar a expressão regular, o sistema determina automaticamente o formato do campo de saída com base no número e nos nomes dos grupos de captura. As regras são as seguintes:

  Em uma expressão regular para um caminho de arquivo, você deve usar escape para as barras ( / ).

  Tipo de grupo de captura	Caso de uso	Campo gerado	Exemplo de regex	Exemplo de caminho correspondente	Exemplo de campo gerado
  Grupo de captura único (apenas um (.*?))	Quando você precisa de apenas uma dimensão para distinguir origens, como por nome de usuário ou ambiente.	Gera o campo __topic__.	\/logs\/(.*?)\/app\.log	/logs/userA/app.log	__topic__: userA
  Vários grupos de captura - Sem nome (vários (.*?))	Quando você precisa de várias dimensões para distinguir origens, mas não requer rótulos semânticos.	Gera o campo de tag __tag__:__topic_{i}__, em que {i} é o índice do grupo de captura.	\/logs\/(.*?)\/(.*?)\/app\.log	/logs/userA/svcA/app.log	__tag__:__topic_1__:userA; __tag__:__topic_2__:svcA
  Vários grupos de captura nomeados (usando (?P<name>.*？)	Quando você precisa de várias dimensões para distinguir origens e deseja nomes de campos claros e significativos para facilitar a consulta e a análise.	Gera o campo de tag __tag__:{name}	\/logs\/(?P<user>.*?)\/(?P<service>.*?)\/app\.log	/logs/userA/svcA/app.log	__tag__:user:userA; __tag__:service:svcA

Adicionar um servidor a um grupo de máquinas

Para adicionar um novo servidor, como uma instância ECS recém-implantada ou um servidor autogerenciado, a um grupo de máquinas existente, associe-o ao grupo para que a configuração de coleta seja aplicada automaticamente.

Pré-requisitos

• Um grupo de máquinas existente.

• O LoongCollector (Logtail) está installed no novo servidor.

Procedimento

1. Visualize o identificador do grupo de máquinas de destino.

   1. No Projeto de destino, clique em Resources > Machine Groups no painel de navegação à esquerda.

   2. Na página Machine Groups, clique no nome do grupo de máquinas de destino.

   3. Na página de configuração do grupo de máquinas, visualize o identificador do grupo de máquinas.

2. Execute uma das seguintes ações com base no tipo de identificador.

   Nota

   Um único grupo de máquinas não pode conter servidores Linux e Windows simultaneamente. Não configure o mesmo identificador definido pelo usuário em servidores Linux e Windows. Para configurar vários identificadores definidos pelo usuário em um único servidor, separe-os com uma quebra de linha.

   • Tipo 1: O identificador do grupo de máquinas é um endereço IP

     1. No servidor, execute o seguinte comando para abrir o arquivo app_info.json e visualizar o valor de ip.

        cat /usr/local/ilogtail/app_info.json

     2. Na página de configuração do grupo de máquinas de destino, clique em Modify e insira o endereço IP do servidor. Se você tiver vários endereços IP, separe-os com quebras de linha.

     3. Após concluir a configuração, clique em Save e confirme o status do heartbeat. Se o status for OK, o servidor aplica automaticamente a configuração de coleta do grupo de máquinas.

        Se o status do heartbeat for FAIL, consulte Machine group heartbeat is FAIL para obter instruções de solução de problemas.

   • Tipo 2: O identificador do grupo de máquinas é um identificador definido pelo usuário

     Com base no sistema operacional, grave a string do identificador definido pelo usuário que corresponde ao grupo de máquinas de destino no arquivo especificado:

     Se o diretório não existir, crie-o manualmente. O caminho e o nome do arquivo são fixos no Log Service e não podem ser personalizados.

     • Linux: Grave uma string personalizada no arquivo /etc/ilogtail/user_defined_id.

     • Windows: Grave uma string personalizada em C:\LogtailData\user_defined_id.

Extraia campos de log com expressões regulares e converta os logs em pares chave-valor. É possível consultar e analisar cada campo de forma independente.

127.0.0.1 - - [16/Aug/2024:14:37:52 +0800] "GET /wp-admin/admin-ajax.php?action=rest-nonce HTTP/1.1" 200 41 "http://www.example.com/wp-admin/post-new.php?post_type=page" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0"

body_bytes_sent: 41
    http_referer: http://www.example.com/wp-admin/post-new.php?post_type=page
    http_user_agent: Mozilla/5.0 (Windows NT 10.0; Win64; ×64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0
    remote_addr: 127.0.0.1
    remote_user: -
    request_method: GET
    request_protocol: HTTP/1.1
    request_uri: /wp-admin/admin-ajax.php?action=rest-nonce
    status: 200
    time_local: 16/Aug/2024:14:37:52 +0800

Procedimento: Na página Logtail Configuration, na área Processor Configurations, clique em Add Processor e selecione Native Processor > Data Parsing (Regex Mode):

• Regular Expression: Usada para corresponder aos logs. Gere-a automaticamente ou insira-a manualmente:

  • Geração automática:

    • Clique em Generate Regex Automatically.

    • No Log Sample, selecione o conteúdo do log a ser extraído.

    • Clique em Generate Regex.

  • Entrada manual: insira a expressão regular manualmente com base no formato do log.

  Após concluir a configuração, clique em Validate para testar se a expressão regular consegue analisar corretamente o conteúdo do log.

• Extracted Field: Defina o nome do campo correspondente (chave) para o conteúdo do log extraído (valor).

Estruture o conteúdo do log usando um separador, convertendo-o em vários pares chave-valor. Há suporte para separadores de um ou vários caracteres.

05/May/2025:13:30:28,10.10.*.*,"POST /PutData?Category=YunOsAccountOpLog&AccessKeyId=****************&Date=Fri%2C%2028%20Jun%202013%2006%3A53%3A30%20GMT&Topic=raw&Signature=******************************** HTTP/1.1",200,18204,aliyun-sdk-java

ip:10.10.*.*
    request:POST /PutData?Category=YunOsAccountOpLog&AccessKeyId=****************&Date=Fri%2C%2028%20Jun%202013%2006%3A53%3A30%20GMT&Topic=raw&Signature=******************************** HTTP/1.1
    size:18204
    status:200
    time:05/May/2025:13:30:28
    user_agent:aliyun-sdk-java

Procedimento: Na página Logtail Configuration, na área Processor Configurations, clique em Add Processor e selecione Native Processor > Data Parsing (Delimiter Mode):

• Delimiter: Especifique o caractere usado para dividir o conteúdo do log.

  Exemplo: Para um arquivo CSV, selecione Custom e insira uma vírgula (,).

• Quote: Quando o valor de um campo contém o separador, é necessário especificar aspas para envolver o campo e evitar divisões incorretas.

• Extracted Field: Defina o nome do campo correspondente (chave) para cada coluna na ordem de separação. As regras são as seguintes:

  • Os nomes dos campos podem conter apenas letras, dígitos e sublinhados (_).

  • Devem começar com uma letra ou um sublinhado (_).

  • Comprimento máximo: 128 bytes.

Estrutura um log JSON do tipo objeto, convertendo-o em pares chave-valor.

{"url": "POST /PutData?Category=YunOsAccountOpLog&AccessKeyId=U0Ujpek********&Date=Fri%2C%2028%20Jun%202013%2006%3A53%3A30%20GMT&Topic=raw&Signature=pD12XYLmGxKQ%2Bmkd6x7hAgQ7b1c%3D HTTP/1.1", "ip": "10.200.98.220", "user-agent": "aliyun-sdk-java", "request": {"status": "200", "latency": "18204"}, "time": "05/Jan/2025:13:30:28"}

ip: 10.200.98.220
    request: {"status": "200", "latency" : "18204" }
    time: 05/Jan/2025:13:30:28
    url: POST /PutData?Category=YunOsAccountOpLog&AccessKeyId=U0Ujpek******&Date=Fri%2C%2028%20Jun%202013%2006%3A53%3A30%20GMT&Topic=raw&Signature=pD12XYLmGxKQ%2Bmkd6x7hAgQ7b1c%3D HTTP/1.1
    user-agent:aliyun-sdk-java

Procedimento: Na página Logtail Configuration, na área Processor Configurations, clique em Add Processor e selecione Native Processor > Data Parsing (JSON Mode):

• Original Field: O valor padrão é content. Este campo é usado para armazenar o conteúdo bruto do log a ser analisado.

Analisa logs JSON aninhados em pares chave-valor ao especificar a profundidade de expansão.

{"s_key":{"k1":{"k2":{"k3":{"k4":{"k51":"51","k52":"52"},"k41":"41"}}}}}

0_s_key_k1_k2_k3_k41:41
    0_s_key_k1_k2_k3_k4_k51:51
    0_s_key_k1_k2_k3_k4_k52:52

1_s_key:{"k1":{"k2":{"k3":{"k4":{"k51":"51","k52":"52"},"k41":"41"}}}}

Procedimento: Na página Logtail Configuration, na área Processor Configurations, clique em Add Processor e selecione Extended Processor > Expand JSON Field:

• Original Field: O nome do campo de origem a ser expandido, por exemplo, content.

• JSON Expansion Depth: O nível de expansão do objeto JSON. 0 significa expansão total (padrão), 1 significa o nível atual, e assim por diante.

• Character to Concatenate Expanded Keys: O separador para nomes de campos durante a expansão JSON. O padrão é um sublinhado _.

• Name Prefix of Expanded Keys: Especifique o prefixo para os nomes dos campos após a expansão JSON.

• Expand Array: Ative esta opção para expandir um array em pares chave-valor com índices.

  Exemplo: {"k":["a","b"]} é expandido para {"k[0]":"a","k[1]":"b"}.

  Para renomear os campos expandidos, por exemplo, de prefix_s_key_k1 para new_field_name, adicione um plugin Rename Fields posteriormente para concluir o mapeamento.

Use a função json_extract function para extrair objetos JSON de um array JSON.

Exemplo:

[{"key1":"value1"},{"key2":"value2"}]

json1:{"key1":"value1"}
    json2:{"key2":"value2"}

Procedimento: Na página Logtail Configuration, na área Processor Configurations, altere o Processing Method para SPL, configure a SPL Statement e use a função json_extract para extrair objetos JSON do array JSON.

Exemplo: Extraia elementos do array JSON no campo de log content e armazene os resultados nos novos campos json1 e json2.

* | extend json1 = json_extract(content, '$[0]'), json2 = json_extract(content, '$[1]')

#Fields: date time s-sitename s-ip cs-method cs-uri-stem cs-uri-query s-port cs-username c-ip cs(User-Agent) sc-status sc-substatus sc-win32-status sc-bytes cs-bytes time-taken

c-ip: cs-username
    cs-bytes: sc-substatus
    cs-method: cs-method
    cs-uri-query: cs-uri-query
    cs-uri-stem: cs-uri-stem
    cs-username: s-port
    date: #Fields:
    s-computername: s-sitename
    s-ip: s-ip
    s-sitename: time
    sc-bytes: sc-status
    sc-status: c-ip
    sc-win32-status: cs (User-Agent)
    time: date
    time-taken: sc-win32-status

• Para obter informações sobre outros parâmetros, consulte as descrições gerais de parâmetros em Scenario 2: Structured Logs.

Mascaramento de dados

[{'account':'1812213231432969','password':'04a23f38'}, {'account':'1812213685634','password':'123a'}]

[{'account':'1812213231432969','password':'********'}, {'account':'1812213685634','password':'********'}]

Analisa o campo de tempo no log e define o resultado da análise como o campo __time__ do log.

Exemplo:

{"level":"INFO","timestamp":"2025-09-23T19:11:47+0800","cluster":"yilu-cluster-0728","message":"User logged in successfully","userId":"user-123"}

Procedimento: Na página Logtail Configuration, na área Processor Configurations, clique em Add Processor e selecione Native Processor > Time Parsing:

• Original Field: O campo de origem que contém o conteúdo do log antes da análise.

• Time Format: Defina o formato de tempo correspondente com base no conteúdo de tempo no log.

• Time Zone: Selecione o fuso horário do campo de tempo do log. Por padrão, o fuso horário da máquina é usado, que é o fuso horário do ambiente onde o processo LoongCollector (Logtail) está em execução.