path: root/src/go/collectors/go.d.plugin/modules/squidlog/charts.go

// SPDX-License-Identifier: GPL-3.0-or-later

package squidlog

import (
	"errors"

	"github.com/netdata/netdata/go/go.d.plugin/agent/module"
)

type (
	Charts = module.Charts
	Chart  = module.Chart
	Dims   = module.Dims
	Dim    = module.Dim
)

const (
	prioReqTotal = module.Priority + iota
	prioReqExcluded
	prioReqType

	prioHTTPRespCodesClass
	prioHTTPRespCodes

	prioUniqClients

	prioBandwidth

	prioRespTime

	prioCacheCode
	prioCacheTransportTag
	prioCacheHandlingTag
	prioCacheObjectTag
	prioCacheLoadSourceTag
	prioCacheErrorTag

	prioReqMethod

	prioHierCode
	prioServers

	prioMimeType
)

var (
	// Requests
	reqTotalChart = Chart{
		ID:       "requests",
		Title:    "Total Requests",
		Units:    "requests/s",
		Fam:      "requests",
		Ctx:      "squidlog.requests",
		Priority: prioReqTotal,
		Dims: Dims{
			{ID: "requests", Algo: module.Incremental},
		},
	}
	reqExcludedChart = Chart{
		ID:       "excluded_requests",
		Title:    "Excluded Requests",
		Units:    "requests/s",
		Fam:      "requests",
		Ctx:      "squidlog.excluded_requests",
		Priority: prioReqExcluded,
		Dims: Dims{
			{ID: "unmatched", Algo: module.Incremental},
		},
	}
	reqTypesChart = Chart{
		ID:       "requests_by_type",
		Title:    "Requests By Type",
		Units:    "requests/s",
		Fam:      "requests",
		Ctx:      "squidlog.type_requests",
		Type:     module.Stacked,
		Priority: prioReqType,
		Dims: Dims{
			{ID: "req_type_success", Name: "success", Algo: module.Incremental},
			{ID: "req_type_bad", Name: "bad", Algo: module.Incremental},
			{ID: "req_type_redirect", Name: "redirect", Algo: module.Incremental},
			{ID: "req_type_error", Name: "error", Algo: module.Incremental},
		},
	}

	// HTTP Code
	httpRespCodeClassChart = Chart{
		ID:       "responses_by_http_status_code_class",
		Title:    "Responses By HTTP Status Code Class",
		Units:    "responses/s",
		Fam:      "http code",
		Ctx:      "squidlog.http_status_code_class_responses",
		Type:     module.Stacked,
		Priority: prioHTTPRespCodesClass,
		Dims: Dims{
			{ID: "http_resp_2xx", Name: "2xx", Algo: module.Incremental},
			{ID: "http_resp_5xx", Name: "5xx", Algo: module.Incremental},
			{ID: "http_resp_3xx", Name: "3xx", Algo: module.Incremental},
			{ID: "http_resp_4xx", Name: "4xx", Algo: module.Incremental},
			{ID: "http_resp_1xx", Name: "1xx", Algo: module.Incremental},
			{ID: "http_resp_0xx", Name: "0xx", Algo: module.Incremental},
			{ID: "http_resp_6xx", Name: "6xx", Algo: module.Incremental},
		},
	}
	httpRespCodesChart = Chart{
		ID:       "responses_by_http_status_code",
		Title:    "Responses By HTTP Status Code",
		Units:    "responses/s",
		Fam:      "http code",
		Ctx:      "squidlog.http_status_code_responses",
		Type:     module.Stacked,
		Priority: prioHTTPRespCodes,
	}

	// Bandwidth
	bandwidthChart = Chart{
		ID:       "bandwidth",
		Title:    "Bandwidth",
		Units:    "kilobits/s",
		Fam:      "bandwidth",
		Ctx:      "squidlog.bandwidth",
		Priority: prioBandwidth,
		Dims: Dims{
			{ID: "bytes_sent", Name: "sent", Algo: module.Incremental, Div: 1000},
		},
	}

	// Response Time
	respTimeChart = Chart{
		ID:       "response_time",
		Title:    "Response Time",
		Units:    "milliseconds",
		Fam:      "timings",
		Ctx:      "squidlog.response_time",
		Priority: prioRespTime,
		Dims: Dims{
			{ID: "resp_time_min", Name: "min", Div: 1000},
			{ID: "resp_time_max", Name: "max", Div: 1000},
			{ID: "resp_time_avg", Name: "avg", Div: 1000},
		},
	}

	// Clients
	uniqClientsChart = Chart{
		ID:       "uniq_clients",
		Title:    "Unique Clients",
		Units:    "clients/s",
		Fam:      "clients",
		Ctx:      "squidlog.uniq_clients",
		Priority: prioUniqClients,
		Dims: Dims{
			{ID: "uniq_clients", Name: "clients"},
		},
	}

	// Cache Code Result
	cacheCodeChart = Chart{
		ID:       "requests_by_cache_result_code",
		Title:    "Requests By Cache Result Code",
		Units:    "requests/s",
		Fam:      "cache result",
		Ctx:      "squidlog.cache_result_code_requests",
		Priority: prioCacheCode,
		Type:     module.Stacked,
	}
	cacheCodeTransportTagChart = Chart{
		ID:       "requests_by_cache_result_code_transport_tag",
		Title:    "Requests By Cache Result Delivery Transport Tag",
		Units:    "requests/s",
		Fam:      "cache result",
		Ctx:      "squidlog.cache_result_code_transport_tag_requests",
		Type:     module.Stacked,
		Priority: prioCacheTransportTag,
	}
	cacheCodeHandlingTagChart = Chart{
		ID:       "requests_by_cache_result_code_handling_tag",
		Title:    "Requests By Cache Result Handling Tag",
		Units:    "requests/s",
		Fam:      "cache result",
		Ctx:      "squidlog.cache_result_code_handling_tag_requests",
		Type:     module.Stacked,
		Priority: prioCacheHandlingTag,
	}
	cacheCodeObjectTagChart = Chart{
		ID:       "requests_by_cache_code_object_tag",
		Title:    "Requests By Cache Result Produced Object Tag",
		Units:    "requests/s",
		Fam:      "cache result",
		Ctx:      "squidlog.cache_code_object_tag_requests",
		Type:     module.Stacked,
		Priority: prioCacheObjectTag,
	}
	cacheCodeLoadSourceTagChart = Chart{
		ID:       "requests_by_cache_code_load_source_tag",
		Title:    "Requests By Cache Result Load Source Tag",
		Units:    "requests/s",
		Fam:      "cache result",
		Ctx:      "squidlog.cache_code_load_source_tag_requests",
		Type:     module.Stacked,
		Priority: prioCacheLoadSourceTag,
	}
	cacheCodeErrorTagChart = Chart{
		ID:       "requests_by_cache_code_error_tag",
		Title:    "Requests By Cache Result Errors Tag",
		Units:    "requests/s",
		Fam:      "cache result",
		Ctx:      "squidlog.cache_code_error_tag_requests",
		Type:     module.Stacked,
		Priority: prioCacheErrorTag,
	}

	// HTTP Method
	reqMethodChart = Chart{
		ID:       "requests_by_http_method",
		Title:    "Requests By HTTP Method",
		Units:    "requests/s",
		Fam:      "http method",
		Ctx:      "squidlog.http_method_requests",
		Type:     module.Stacked,
		Priority: prioReqMethod,
	}

	// MIME Type
	mimeTypeChart = Chart{
		ID:       "requests_by_mime_type",
		Title:    "Requests By MIME Type",
		Units:    "requests/s",
		Fam:      "mime type",
		Ctx:      "squidlog.mime_type_requests",
		Type:     module.Stacked,
		Priority: prioMimeType,
	}

	// Hierarchy
	hierCodeChart = Chart{
		ID:       "requests_by_hier_code",
		Title:    "Requests By Hierarchy Code",
		Units:    "requests/s",
		Fam:      "hierarchy",
		Ctx:      "squidlog.hier_code_requests",
		Type:     module.Stacked,
		Priority: prioHierCode,
	}
	serverAddrChart = Chart{
		ID:       "forwarded_requests_by_server_address",
		Title:    "Forwarded Requests By Server Address",
		Units:    "requests/s",
		Fam:      "hierarchy",
		Ctx:      "squidlog.server_address_forwarded_requests",
		Type:     module.Stacked,
		Priority: prioServers,
	}
)

func (s *SquidLog) createCharts(line *logLine) error {
	if line.empty() {
		return errors.New("empty line")
	}
	charts := &Charts{
		reqTotalChart.Copy(),
		reqExcludedChart.Copy(),
	}
	if line.hasRespTime() {
		if err := addRespTimeCharts(charts); err != nil {
			return err
		}
	}
	if line.hasClientAddress() {
		if err := addClientAddressCharts(charts); err != nil {
			return err
		}
	}
	if line.hasCacheCode() {
		if err := addCacheCodeCharts(charts); err != nil {
			return err
		}
	}
	if line.hasHTTPCode() {
		if err := addHTTPRespCodeCharts(charts); err != nil {
			return err
		}
	}
	if line.hasRespSize() {
		if err := addRespSizeCharts(charts); err != nil {
			return err
		}
	}
	if line.hasReqMethod() {
		if err := addMethodCharts(charts); err != nil {
			return err
		}
	}
	if line.hasHierCode() {
		if err := addHierCodeCharts(charts); err != nil {
			return err
		}
	}
	if line.hasServerAddress() {
		if err := addServerAddressCharts(charts); err != nil {
			return err
		}
	}
	if line.hasMimeType() {
		if err := addMimeTypeCharts(charts); err != nil {
			return err
		}
	}
	s.charts = charts
	return nil
}

func addRespTimeCharts(charts *Charts) error {
	return charts.Add(respTimeChart.Copy())
}

func addClientAddressCharts(charts *Charts) error {
	return charts.Add(uniqClientsChart.Copy())
}

func addCacheCodeCharts(charts *Charts) error {
	cs := []Chart{
		cacheCodeChart,
		cacheCodeTransportTagChart,
		cacheCodeHandlingTagChart,
		cacheCodeObjectTagChart,
		cacheCodeLoadSourceTagChart,
		cacheCodeErrorTagChart,
	}
	for _, chart := range cs {
		if err := charts.Add(chart.Copy()); err != nil {
			return err
		}
	}
	return nil
}
func addHTTPRespCodeCharts(charts *Charts) error {
	cs := []Chart{
		reqTypesChart,
		httpRespCodeClassChart,
		httpRespCodesChart,
	}
	for _, chart := range cs {
		if err := charts.Add(chart.Copy()); err != nil {
			return err
		}
	}
	return nil
}

func addRespSizeCharts(charts *Charts) error {
	return charts.Add(bandwidthChart.Copy())
}

func addMethodCharts(charts *Charts) error {
	return charts.Add(reqMethodChart.Copy())
}

func addHierCodeCharts(charts *Charts) error {
	return charts.Add(hierCodeChart.Copy())
}
func addServerAddressCharts(charts *Charts) error {
	return charts.Add(serverAddrChart.Copy())
}

func addMimeTypeCharts(charts *Charts) error {
	return charts.Add(mimeTypeChart.Copy())
}