Simple Log Service:Get started with Simple Log Service SDK for Go

In this example, a file named SLSQuickStart.go is created. The sample code in this file provides an example on how to call API operations to create a project, create a Logstore, create indexes, write logs, and query logs. Example:

package main

import (
	"fmt"
	"log"
	"math/rand"
	"os"
	"time"

	sls "github.com/aliyun/aliyun-log-go-sdk"
	"github.com/gogo/protobuf/proto"
)

func main() {
	// The Simple Log Service endpoint. In this example, the Simple Log Service endpoint for the China (Hangzhou) region is used. Replace the parameter value with the actual endpoint. 
	Endpoint := "cn-hangzhou.log.aliyuncs.com"

	// In this example, the AccessKey ID and AccessKey secret are obtained from environment variables. 
	AccessKeyId := os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_ID")
	AccessKeySecret := os.Getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET")
	// The STS token of the RAM user. If you leave this parameter empty, no STS tokens are used. 
	SecurityToken := ""
	// Create a Simple Log Service client. 
	provider := sls.NewStaticCredentialsProvider(AccessKeyId, AccessKeySecret, SecurityToken)
	client := sls.CreateNormalInterfaceV2(Endpoint, provider)

	// Create a project. 
	ProjectName := "aliyun-test-project"
	Description := "test"
	project, err := client.CreateProject(ProjectName, Description)
	if err != nil {
		if e, ok := err.(*sls.Error); ok && e.Code == "ProjectAlreadyExist" {
			log.Printf("Project : %s already created or has an global name conflict in Aliyun scope", ProjectName)
		} else {
			log.Fatalf("Create project : %s failed %v", ProjectName, err)
			os.Exit(1)
		}
	} else {
		log.Printf("Project : %s created successfully", project.Name)
		time.Sleep(60 * time.Second)
	}

	// Create a Logstore. 
	LogStoreName := "aliyun-test-logstore"
	err = client.CreateLogStore(ProjectName, LogStoreName, 3, 2, true, 6)
	if err != nil {
		if e, ok := err.(*sls.Error); ok && e.Code == "LogStoreAlreadyExist" {
			log.Printf("Logstore : %s already created", LogStoreName)
		} else {
			log.Fatalf("Create LogStore : %s failed %v", LogStoreName, err)
			os.Exit(1)
		}
	} else {
		log.Printf("Create logstore : %v successfully", LogStoreName)
		time.Sleep(10 * time.Second)
	}

	// Create indexes for the Logstore. 
	index := sls.Index{
		// Field indexing. 
		Keys: map[string]sls.IndexKey{
			"col_0": {
				Token:         []string{" "},
				CaseSensitive: false,
				Type:          "long",
			},
			"col_1": {
				Token:         []string{",", ":", " "},
				CaseSensitive: false,
				Type:          "text",
			},
		},
		// Full-text indexing. 
		Line: &sls.IndexLine{
			Token:         []string{",", ":", " "},
			CaseSensitive: false,
			IncludeKeys:   []string{},
			ExcludeKeys:   []string{},
		},
	}
	err = client.CreateIndex(ProjectName, LogStoreName, index)
	if err != nil {
		if e, ok := err.(*sls.Error); ok && e.Code == "IndexAlreadyExist" {
			log.Printf("Index : already created")
		} else {
			log.Fatalf("Create Index failed %v", err)
			os.Exit(1)
		}
	} else {
		log.Println("CreateIndex success")
		time.Sleep(60 * time.Second)
	}

	// Write logs to the Logstore. 
	for loggroupIdx := 0; loggroupIdx < 10; loggroupIdx++ {
		logs := []*sls.Log{}
		for logIdx := 0; logIdx < 100; logIdx++ {
			content := []*sls.LogContent{}
			for colIdx := 0; colIdx < 10; colIdx++ {
				if colIdx == 0 {
					content = append(content, &sls.LogContent{
						Key:   proto.String(fmt.Sprintf("col_%d", colIdx)),
						Value: proto.String(fmt.Sprintf("%d", rand.Intn(10000000))),
					})
				} else {
					content = append(content, &sls.LogContent{
						Key:   proto.String(fmt.Sprintf("col_%d", colIdx)),
						Value: proto.String(fmt.Sprintf("loggroup idx: %d, log idx: %d, col idx: %d, value: %d", loggroupIdx, logIdx, colIdx, rand.Intn(10000000))),
					})
				}
			}
			log := &sls.Log{
				Time:     proto.Uint32(uint32(time.Now().Unix())),
				Contents: content,
			}
			logs = append(logs, log)
		}
		loggroup := &sls.LogGroup{
			Topic:  proto.String("test"),
			Source: proto.String("203.0.113.10"),
			Logs:   logs,
		}

		err = client.PutLogs(ProjectName, LogStoreName, loggroup)
		if err != nil {
			log.Fatalf("PutLogs failed %v", err)
			os.Exit(1)
		}
		log.Println("PutLogs success")
		time.Sleep(time.Second)
	}

	// Execute an SQL statement to query logs. 
	// If the query statement includes only a search statement, the values of the line, offset, and reverse parameters take effect. The line parameter specifies the maximum number of logs that can be returned. Maximum value: 100. The offset parameter specifies the start position of the returned logs. To paginate logs, you can configure the line and offset parameters. 
	// For example, you can set the line parameter to 100 and the offset parameter to 0 for the first query statement, and set the line parameter to 100 and the offset parameter to 100 for the second query statement. 
	// If the query statement includes an analytic statement, the values of the line, offset, and reverse parameters do not take effect. The number of logs that are returned is determined by the LIMIT, OFFSET, and ORDER BY clauses. We recommend that you set the values of the line, offset, and reverse parameters to 0, 0, and false, respectively. If you specify other values for the parameters, errors are reported. 
	// For more information, see Paged query. 
	response, err := client.GetLogs(ProjectName, LogStoreName, "test", time.Now().Unix()-1800, time.Now().Unix(), "* and col_0 > 9000000", 100, 1, true)
	if err != nil {
		log.Fatalf("GetLogs failed %v", err)
		os.Exit(1)
	}
	log.Printf("Get %d logs", response.Count)
	logs := response.Logs
	for i := range logs {
		for k, v := range logs[i] {
			log.Printf("key: %s, value: %s", k, v)
		}
		log.Println("======")
	}
}