github.com/verrazzano/verrazzano@v1.7.1/tools/psr/backend/workers/opensearch/postlogs/postlogs.go

// Copyright (c) 2022, Oracle and/or its affiliates.
// Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.

package postlogs

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"sync/atomic"
	"time"

	"github.com/prometheus/client_golang/prometheus"
	"github.com/verrazzano/verrazzano/pkg/log/vzlog"
	"github.com/verrazzano/verrazzano/pkg/security/password"
	"github.com/verrazzano/verrazzano/tools/psr/backend/config"
	"github.com/verrazzano/verrazzano/tools/psr/backend/metrics"
	"github.com/verrazzano/verrazzano/tools/psr/backend/osenv"
	"github.com/verrazzano/verrazzano/tools/psr/backend/spi"
)

const (
	// metricsPrefix is the prefix that is automatically pre-pended to all metrics exported by this worker.
	metricsPrefix = "opensearch_postlogs"

	LogEntries      = "LOG_ENTRIES"
	LogLength       = "LOG_LENGTH"
	osIngestService = "vmi-system-os-ingest.verrazzano-system:9200"
)

// Use an http client interface so that we can override http.Client for unit tests
type httpClientI interface {
	Do(_ *http.Request) (resp *http.Response, err error)
}

var httpClient httpClientI = &http.Client{}
var _ httpClientI = &http.Client{}

type worker struct {
	metricDescList []prometheus.Desc
	*workerMetrics
}

var _ spi.Worker = worker{}

// workerMetrics holds the metrics produced by the worker. Metrics must be thread safe.
type workerMetrics struct {
	openSearchPostSuccessCountTotal         metrics.MetricItem
	openSearchPostFailureCountTotal         metrics.MetricItem
	openSearchPostSuccessLatencyNanoSeconds metrics.MetricItem
	openSearchPostFailureLatencyNanoSeconds metrics.MetricItem
	openSearchPostDataCharsTotal            metrics.MetricItem
}

func NewPostLogsWorker() (spi.Worker, error) {
	w := worker{workerMetrics: &workerMetrics{
		openSearchPostSuccessCountTotal: metrics.MetricItem{
			Name: "success_count_total",
			Help: "The total number of successful OpenSearch POST requests",
			Type: prometheus.CounterValue,
		},
		openSearchPostFailureCountTotal: metrics.MetricItem{
			Name: "failure_count_total",
			Help: "The total number of successful OpenSearch POST requests",
			Type: prometheus.CounterValue,
		},
		openSearchPostSuccessLatencyNanoSeconds: metrics.MetricItem{
			Name: "success_latency_nanoseconds",
			Help: "The latency of successful OpenSearch POST requests in nanoseconds",
			Type: prometheus.GaugeValue,
		},
		openSearchPostFailureLatencyNanoSeconds: metrics.MetricItem{
			Name: "failure_latency_nanoseconds",
			Help: "The latency of failed OpenSearch POST requests in nanoseconds",
			Type: prometheus.GaugeValue,
		},
		openSearchPostDataCharsTotal: metrics.MetricItem{
			Name: "data_chars_total",
			Help: "The total number of characters posted to OpenSearch",
			Type: prometheus.CounterValue,
		},
	}}

	if err := config.PsrEnv.LoadFromEnv(w.GetEnvDescList()); err != nil {
		return w, err
	}

	metricsLabels := map[string]string{
		config.PsrWorkerTypeMetricsName: config.PsrEnv.GetEnv(config.PsrWorkerType),
	}

	w.metricDescList = metrics.BuildMetricDescList([]*metrics.MetricItem{
		&w.openSearchPostSuccessCountTotal,
		&w.openSearchPostFailureCountTotal,
		&w.openSearchPostSuccessLatencyNanoSeconds,
		&w.openSearchPostFailureLatencyNanoSeconds,
		&w.openSearchPostDataCharsTotal,
	}, metricsLabels, w.GetWorkerDesc().MetricsPrefix)

	return w, nil
}

// GetWorkerDesc returns the WorkerDesc for the worker
func (w worker) GetWorkerDesc() spi.WorkerDesc {
	return spi.WorkerDesc{
		WorkerType:    config.WorkerTypeOpsPostLogs,
		Description:   "The postlogs worker performs POST requests on the OpenSearch endpoint",
		MetricsPrefix: metricsPrefix,
	}
}

func (w worker) GetEnvDescList() []osenv.EnvVarDesc {
	return []osenv.EnvVarDesc{
		{Key: LogEntries, DefaultVal: "1", Required: false},
		{Key: LogLength, DefaultVal: "1", Required: false},
	}
}

func (w worker) WantLoopInfoLogged() bool {
	return false
}

func (w worker) PreconditionsMet() (bool, error) {
	return true, nil
}

func (w worker) DoWork(conf config.CommonConfig, log vzlog.VerrazzanoLogger) error {
	c := httpClient
	logEntries, err := strconv.Atoi(config.PsrEnv.GetEnv(LogEntries))
	if err != nil {
		return err
	}
	logLength, err := strconv.Atoi(config.PsrEnv.GetEnv(LogLength))
	if err != nil {
		return err
	}

	body, bodyChars, err := getBody(logEntries, logLength)
	if err != nil {
		return err
	}

	req := http.Request{
		Method: "POST",
		URL: &url.URL{
			Scheme: "http",
			Host:   osIngestService,
			Path:   fmt.Sprintf("/verrazzano-application-%s/_bulk", conf.Namespace),
		},
		Header: http.Header{"Content-Type": {"application/json"}},
		Body:   body,
	}

	startRequest := time.Now().UnixNano()
	resp, err := c.Do(&req)
	if err != nil {
		atomic.AddInt64(&w.workerMetrics.openSearchPostFailureCountTotal.Val, 1)
		return err
	}
	if resp == nil {
		atomic.AddInt64(&w.workerMetrics.openSearchPostFailureCountTotal.Val, 1)
		return fmt.Errorf("POST request to URI %s received a nil response", req.URL.RequestURI())
	}

	if resp.StatusCode != 200 && resp.StatusCode != 201 {
		atomic.StoreInt64(&w.workerMetrics.openSearchPostFailureLatencyNanoSeconds.Val, time.Now().UnixNano()-startRequest)
		atomic.AddInt64(&w.workerMetrics.openSearchPostFailureCountTotal.Val, 1)
		return fmt.Errorf("OpenSearch POST request failed, returned %v status code with status: %s", resp.StatusCode, resp.Status)
	}
	atomic.StoreInt64(&w.workerMetrics.openSearchPostSuccessLatencyNanoSeconds.Val, time.Now().UnixNano()-startRequest)
	atomic.AddInt64(&w.workerMetrics.openSearchPostSuccessCountTotal.Val, 1)
	atomic.AddInt64(&w.workerMetrics.openSearchPostDataCharsTotal.Val, bodyChars)
	return nil
}

func (w worker) GetMetricDescList() []prometheus.Desc {
	return w.metricDescList
}

func (w worker) GetMetricList() []prometheus.Metric {
	return []prometheus.Metric{
		w.openSearchPostSuccessCountTotal.BuildMetric(),
		w.openSearchPostFailureCountTotal.BuildMetric(),
		w.openSearchPostSuccessLatencyNanoSeconds.BuildMetric(),
		w.openSearchPostFailureLatencyNanoSeconds.BuildMetric(),
		w.openSearchPostDataCharsTotal.BuildMetric(),
	}
}

func getBody(logCount int, dataLength int) (io.ReadCloser, int64, error) {
	var body string
	for i := 0; i < logCount; i++ {
		data, err := password.GeneratePassword(dataLength)
		if err != nil {
			return nil, 0, err
		}
		body = body + "{\"create\": {}}\n" + fmt.Sprintf("{\"postlogs-data\":\"%s\",\"@timestamp\":\"%v\"}\n", data, getTimestamp())
	}
	return io.NopCloser(bytes.NewBuffer([]byte(body))), int64(len(body)), nil
}

func getTimestamp() interface{} {
	return fmt.Sprintf("%04d-%02d-%02dT%02d:%02d:%02d",
		time.Now().Year(),
		int(time.Now().Month()),
		time.Now().Day(),
		time.Now().Hour(),
		time.Now().Minute(),
		time.Now().Second(),
	)
}