func GenerateHintsMapping()

in internal/pkg/composable/providers/kubernetes/hints.go [141:255]
105 lines of code
26 McCabe index (conditional complexity)

func GenerateHintsMapping(hints mapstr.M, kubeMeta mapstr.M, logger *logp.Logger, containerID string) mapstr.M {
	builder := hintsBuilder{
		Key:    "hints", // consider doing it a configurable,
		logger: logger,
	}

	hintsMapping := mapstr.M{}
	integration := builder.getIntegration(hints)
	if integration == "" {
		return hintsMapping
	}
	integrationHints := mapstr.M{}

	if containerID != "" {
		_, _ = hintsMapping.Put("container_id", containerID)
		// Add the default container log fallback to enable any template which defines
		// a log input with a `"${kubernetes.hints.container_logs.enabled} == true"` condition
		_, _ = integrationHints.Put("container_logs.enabled", true)
	}

	integrationHost := builder.getFromMeta(builder.getHost(hints), kubeMeta)
	if integrationHost != "" {
		_, _ = integrationHints.Put(host, integrationHost)
	}
	integrationPeriod := builder.getFromMeta(builder.getPeriod(hints), kubeMeta)
	if integrationPeriod != "" {
		_, _ = integrationHints.Put(period, integrationPeriod)
	}
	integrationTimeout := builder.getFromMeta(builder.getTimeout(hints), kubeMeta)
	if integrationTimeout != "" {
		_, _ = integrationHints.Put(timeout, integrationTimeout)
	}
	integrationMetricsPath := builder.getFromMeta(builder.getMetricspath(hints), kubeMeta)
	if integrationMetricsPath != "" {
		_, _ = integrationHints.Put(metricspath, integrationMetricsPath)
	}
	integrationUsername := builder.getFromMeta(builder.getUsername(hints), kubeMeta)
	if integrationUsername != "" {
		_, _ = integrationHints.Put(username, integrationUsername)
	}
	integrationPassword := builder.getFromMeta(builder.getPassword(hints), kubeMeta)
	if integrationPassword != "" {
		_, _ = integrationHints.Put(password, integrationPassword)
	}
	integrationContainerStream := builder.getFromMeta(builder.getContainerStream(hints), kubeMeta)
	if integrationContainerStream != "" {
		_, _ = integrationHints.Put(stream, integrationContainerStream)
	}

	dataStreams := builder.getDataStreams(hints)
	if len(dataStreams) == 0 {
		_, _ = integrationHints.Put("enabled", true)
	}
	for _, dataStream := range dataStreams {
		streamHints := mapstr.M{
			"enabled": true,
		}
		if integrationPeriod != "" {
			_, _ = streamHints.Put(period, integrationPeriod)
		}
		if integrationHost != "" {
			_, _ = streamHints.Put(host, integrationHost)
		}
		if integrationTimeout != "" {
			_, _ = streamHints.Put(timeout, integrationTimeout)
		}
		if integrationMetricsPath != "" {
			_, _ = streamHints.Put(metricspath, integrationMetricsPath)
		}
		if integrationUsername != "" {
			_, _ = streamHints.Put(username, integrationUsername)
		}
		if integrationPassword != "" {
			_, _ = streamHints.Put(password, integrationPassword)
		}
		if integrationContainerStream != "" {
			_, _ = streamHints.Put(stream, integrationContainerStream)
		}

		streamPeriod := builder.getFromMeta(builder.getStreamPeriod(hints, dataStream), kubeMeta)
		if streamPeriod != "" {
			_, _ = streamHints.Put(period, streamPeriod)
		}
		streamHost := builder.getFromMeta(builder.getStreamHost(hints, dataStream), kubeMeta)
		if streamHost != "" {
			_, _ = streamHints.Put(host, streamHost)
		}
		streamTimeout := builder.getFromMeta(builder.getStreamTimeout(hints, dataStream), kubeMeta)
		if streamTimeout != "" {
			_, _ = streamHints.Put(timeout, streamTimeout)
		}
		streamMetricsPath := builder.getFromMeta(builder.getStreamMetricspath(hints, dataStream), kubeMeta)
		if streamMetricsPath != "" {
			_, _ = streamHints.Put(metricspath, streamMetricsPath)
		}
		streamUsername := builder.getFromMeta(builder.getStreamUsername(hints, dataStream), kubeMeta)
		if streamUsername != "" {
			_, _ = streamHints.Put(username, streamUsername)
		}
		streamPassword := builder.getFromMeta(builder.getStreamPassword(hints, dataStream), kubeMeta)
		if streamPassword != "" {
			_, _ = streamHints.Put(password, streamPassword)
		}
		streamContainerStream := builder.getFromMeta(builder.getStreamContainerStream(hints, dataStream), kubeMeta)
		if streamContainerStream != "" {
			_, _ = streamHints.Put(stream, streamContainerStream)
		}
		_, _ = integrationHints.Put(dataStream, streamHints)

	}

	_, _ = hintsMapping.Put(integration, integrationHints)

	return hintsMapping
}