Simple Log Service:Compressão de dados

Comprimir dados da requisição

As operações de API a seguir aceitam dados comprimidos com lz4 no corpo da requisição HTTP.

• PutLogs (PutLogStoreLogs)

• PutWebtracking

Para enviar dados comprimidos:

1. Adicione x-log-compresstype: lz4 ao cabeçalho da requisição HTTP.

2. Comprima o corpo da requisição HTTP com lz4.

3. Defina x-log-bodyrawsize no cabeçalho da requisição como o tamanho do corpo não comprimido.

4. Defina Content-Length no cabeçalho da requisição como o tamanho do corpo comprimido.

Receber dados comprimidos

A operação de API PullLogs pode retornar dados comprimidos com lz4.

Para receber dados comprimidos:

• Defina Accept-Encoding: lz4 no cabeçalho da requisição. O servidor retornará dados comprimidos com lz4.

• Leia x-log-bodyrawsize no cabeçalho da resposta para obter o tamanho do corpo não comprimido. Em seguida, passe esse valor para a função de descompressão.

Exemplos

• Logs brutos

  Os exemplos usam log-sample.json/@filepath como entrada de amostra. Substitua esse arquivo pelos seus dados de log reais ao chamar a API.

  {
    "__tags__": {},
    "__topic__": "",
    "__source__": "47.100.XX.XX",
    "__logs__": [
      {
        "__time__": "03/22 08:51:01",
        "content": "*************** RSVP Agent started ***************",
        "method": "main",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:01",
        "content": "Specified configuration file: /u/user10/rsvpd1.conf",
        "method": "locate_configFile",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:01",
        "content": "Using log level 511",
        "method": "main",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:01",
        "content": "Get TCP images rc - EDC8112I Operation not supported on socket",
        "method": "settcpimage",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:01",
        "content": "Associate with TCP/IP image name = TCPCS",
        "method": "settcpimage",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:02",
        "content": "registering process with the system",
        "method": "reg_process",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:02",
        "content": "attempt OS/390 registration",
        "method": "reg_process",
        "level": "INFO"
      },
      {
        "__time__": "03/22 08:51:02",
        "content": "return from registration rc=0",
        "method": "reg_process",
        "level": "INFO"
      }
    ]
  }

• Programa de teste

  O código Python a seguir comprime o arquivo de amostra e exibe a taxa de compressão:

  from lz4 import block
  with open('log-sample.json', 'rb') as f:
      data = f.read()
      compressed = block.compress(data, store_size=False) # Compress
      print(f'out/in: {len(compressed)}/{len(data)} Bytes')
      print(f'Compression ratio: {len(compressed)/len(data):.2%}')

• Resultado da compressão

  Para log-sample.json/@filepath, a taxa de compressão é de 39,30%. Os resultados reais variam conforme o conteúdo: dados com mais repetição são comprimidos de forma mais eficiente.

  out/in: 542/1379 Bytes
  Compression ratio: 39.30%

Código de exemplo

• Exemplo em Go

  • Instale a biblioteca de dependências

    go get github.com/pierrec/lz4

  • Código de exemplo

    import (
        "fmt"
        "log"
    
        lz4 "github.com/cloudflare/golz4"
    )
    
    func main() {
        data := []byte("hello world, hello golang")
        // Compress
        compressed := make([]byte, lz4.CompressBound(data))
        compressedSize, err := lz4.Compress(data, compressed)
        if err != nil {
            log.Fatal(err)
        }
        compressed = compressed[:compressedSize]
    
        // Decompress
        bodyRawSize := len(data) // To decompress data from Simple Log Service, read x-log-bodyrawsize from the returned HTTP header.
        decompressed := make([]byte, bodyRawSize)
        err = lz4.Uncompress(compressed, decompressed)
        if err != nil {
            log.Fatal(err)
        }
        decompressed = decompressed[:bodyRawSize]
    }

• Exemplo em Python

  • Instale a biblioteca de dependências

    python3 -m pip install lz4

  • Código de exemplo

    from lz4 import block
    
    data = b'hello world, hello sls'
    # Compress
    compressed = block.compress(data, store_size=False)
    
    # Decompress
    body_raw_size=len(data) # When decompressing data from Simple Log Service, read x-log-bodyrawsize from the returned HTTP header.
    decompressed = block.decompress(compressed, uncompressed_size=body_raw_size)

• Exemplo em Java

  • Adicione a dependência do Maven

    <dependency>
      <groupId>net.jpountz.lz4</groupId>
      <artifactId>lz4</artifactId>
      <version>1.3.0</version>
    </dependency>

  • Código de exemplo

    package sample;
    
    import net.jpountz.lz4.LZ4Compressor;
    import net.jpountz.lz4.LZ4Factory;
    import net.jpountz.lz4.LZ4FastDecompressor;
    
    import java.io.File;
    import java.io.IOException;
    import java.nio.file.Files;
    
    public class Sample {
        public static void main(String[] args) throws IOException {
            byte[] data = "hello world, hello sls".getBytes();
            // Compress
            LZ4Compressor compressor = LZ4Factory.fastestInstance().fastCompressor();
            int maxLen = compressor.maxCompressedLength(data.length);
            byte[] buffer = new byte[maxLen];
            int compressedSize = compressor.compress(data, 0, data.length, buffer, 0, maxLen);
            // Copy the buffer data to compressed.
            byte[] compressed = new byte[compressedSize];
            System.arraycopy(buffer, 0, compressed, 0, compressedSize);
    
            // Decompress
            int bodyRawSize = data.length; // When decompressing data from Simple Log Service, read x-log-bodyrawsize from the returned HTTP header.
            LZ4FastDecompressor decompressor = LZ4Factory.fastestInstance().fastDecompressor();
            byte[] decompressed = new byte[bodyRawSize];
            decompressor.decompress(compressed, 0, decompressed, 0, bodyRawSize);
        }
    }

• Exemplo em JavaScript

  • Use npm ou yarn para instalar as bibliotecas de dependências buffer e lz4.

    npm install buffer lz4

  • Código de exemplo

    import lz4 from 'lz4'
    import { Buffer } from 'buffer'
    
    // Compress
    const data = 'hello world, hello sls'
    const output = Buffer.alloc(lz4.encodeBound(data.length))
    const compressedSize = lz4.encodeBlock(Buffer.from(data), output)
    const compressed = Uint8Array.prototype.slice.call(output, 0, compressedSize)
    
    // Decompress
    const bodyRawSize = data.length; // When decompressing data from Simple Log Service, read x-log-bodyrawsize from the returned HTTP header.
    const decompressed = Buffer.alloc(bodyRawSize)
    lz4.decodeBlock(Buffer.from(compressed), decompressed)
    const result = decompressed.toString()

• Exemplo em C++

  • Copie as pastas lz4 e lib do diretório raiz do repositório do SDK C++ para a pasta de destino. Durante a compilação, adicione o caminho de busca da biblioteca lz4 (por exemplo, -L./lib) e vincule à lz4 (por exemplo, -llz4). Para mais informações, consulte Instalar o SDK C++.

    g++ -o your_program your_program.cpp -std=gnu++11 -llz4 -L./lib/

  • Código de exemplo

    #include "lz4/lz4.h"
    #include <string>
    #include <iostream>
    using namespace std;
    
    int main()
    {
        string data = "hello sls, hello lz4";
        // Compress
        string compressed;
        compressed.resize(LZ4_compressBound(data.size()));
        int compressed_size = LZ4_compress(data.c_str(), &compressed[0], data.size());
        compressed.resize(compressed_size);
    
        // Decompress
        string decompressed;
        int bodyRawSize = data.size();
        decompressed.resize(bodyRawSize);
        LZ4_decompress_safe(compressed.c_str(), &decompressed[0], compressed.size(), bodyRawSize);
        cout << decompressed << endl;
        return 0;
    }