Utiliser lz4 pour la compression des données - Simple Log Service

L'envoi de volumes importants de journaux sur le réseau augmente la latence et les coûts. Simple Log Service prend en charge la compression lz4 pour certaines opérations d'API, réduisant ainsi le trafic réseau et améliorant le débit sans perte de données.

Compresser les données de requête

Les opérations d'API suivantes acceptent des données compressées avec lz4 dans le corps de la requête HTTP.

PutLogs (PutLogStoreLogs)
PutWebtracking

Pour envoyer des données compressées :

Ajoutez x-log-compresstype: lz4 à l'en-tête de la requête HTTP.
Compressez le corps de la requête HTTP avec lz4.
Définissez x-log-bodyrawsize dans l'en-tête de la requête sur la taille du corps non compressé.
Définissez Content-Length dans l'en-tête de la requête sur la taille du corps compressé.

Recevoir des données compressées

L'opération d'API PullLogs peut renvoyer des données compressées avec lz4.

Pour recevoir des données compressées :

Définissez Accept-Encoding: lz4 dans l'en-tête de la requête. Le serveur renvoie des données compressées avec lz4.
Lisez x-log-bodyrawsize dans l'en-tête de la réponse pour obtenir la taille du corps non compressé. Transmettez cette valeur à votre fonction de décompression.

Exemples

Journaux bruts

Les exemples utilisent log-sample.json/@filepath comme entrée. Remplacez ce fichier par vos données de journal réelles lors de l'appel de l'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"
    }
  ]
}

Programme de test

Le code Python suivant compresse le fichier exemple et affiche le taux de compression :

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%}')

Résultat de la compression

Pour log-sample.json/@filepath, le taux de compression est de 39,30 %. Les résultats réels varient selon le contenu : les données très redondantes se compressent plus efficacement.
```
out/in: 542/1379 Bytes
Compression ratio: 39.30%
```

Exemple de code

Exemple Go

Installez la bibliothèque de dépendances
```
go get github.com/pierrec/lz4
```

Exemple de code

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]
}

Exemple Python

Installez la bibliothèque de dépendances
```
python3 -m pip install lz4
```

Exemple de code

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)

Exemple Java

Ajoutez la dépendance Maven

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

Exemple de code

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);
    }
}

Exemple JavaScript

Utilisez npm ou yarn pour installer les bibliothèques de dépendances buffer et lz4.
```
npm install buffer lz4
```

Exemple de code

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()

Exemple C++

Copiez les dossiers lz4 et lib depuis le répertoire racine du dépôt du SDK C++ vers votre dossier de destination. Lors de la compilation, ajoutez le chemin de recherche de la bibliothèque lz4 (par exemple, -L./lib) et effectuez l'édition des liens avec lz4 (par exemple, -llz4). Pour plus d'informations, consultez Installer le SDK C++.
```
g++ -o your_program your_program.cpp -std=gnu++11 -llz4 -L./lib/
```

Exemple de code

#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;
}