func()

in pkg/telemetry/telemetry.go [77:170]

• 77 lines of code
• 15 McCabe index (conditional complexity)

func (c *Collector) sendTelemetry(ctx context.Context) error {
	edpConfig := &corev1.ConfigMap{}
	if err := c.k8sClient.Get(ctx, client.ObjectKey{
		Namespace: c.namespace,
		Name:      platform.EdpConfigMap,
	}, edpConfig); err != nil {
		return fmt.Errorf("failed to get edp config: %w", err)
	}

	telemetry := PlatformMetrics{}
	telemetry.RegistryType = edpConfig.Data["container_registry_type"]
	telemetry.Version = edpConfig.Data["edp_version"]

	codebases := &codebaseApi.CodebaseList{}
	if err := c.k8sClient.List(ctx, codebases, client.InNamespace(c.namespace)); err != nil {
		return fmt.Errorf("failed to get codebases: %w", err)
	}

	for i := 0; i < len(codebases.Items); i++ {
		telemetry.CodebaseMetrics = append(telemetry.CodebaseMetrics, CodebaseMetrics{
			Lang:       codebases.Items[i].Spec.Lang,
			Framework:  codebases.Items[i].Spec.Framework,
			BuildTool:  codebases.Items[i].Spec.BuildTool,
			Strategy:   string(codebases.Items[i].Spec.Strategy),
			Type:       codebases.Items[i].Spec.Type,
			Versioning: string(codebases.Items[i].Spec.Versioning.Type),
		})
	}

	gitProviders := &codebaseApi.GitServerList{}
	if err := c.k8sClient.List(ctx, gitProviders, client.InNamespace(c.namespace)); err != nil {
		return fmt.Errorf("failed to get git providers: %w", err)
	}

	if len(gitProviders.Items) > 0 {
		telemetry.GitProviders = append(telemetry.GitProviders, gitProviders.Items[0].Spec.GitProvider)
	}

	stages := &pipelineAPi.StageList{}
	if err := c.k8sClient.List(ctx, stages, client.InNamespace(c.namespace)); err != nil {
		return fmt.Errorf("failed to get stages: %w", err)
	}

	deploymentType := map[string]string{}
	stagesCount := map[string]int{}

	for i := 0; i < len(stages.Items); i++ {
		stagesCount[stages.Items[i].Spec.CdPipeline]++

		if stages.Items[i].Spec.TriggerType == "Auto" {
			deploymentType[stages.Items[i].Spec.CdPipeline] = "Auto"
		}
	}

	cdPipelines := &pipelineAPi.CDPipelineList{}
	if err := c.k8sClient.List(ctx, cdPipelines, client.InNamespace(c.namespace)); err != nil {
		return fmt.Errorf("failed to get cd pipelines: %w", err)
	}

	for i := 0; i < len(cdPipelines.Items); i++ {
		pipeDeployment := "Manual"
		if val, ok := deploymentType[cdPipelines.Items[i].Name]; ok {
			pipeDeployment = val
		}

		telemetry.CdPipelineMetrics = append(telemetry.CdPipelineMetrics, CdPipelineMetrics{
			DeploymentType: pipeDeployment,
			NumberOfStages: stagesCount[cdPipelines.Items[i].Name],
		})
	}

	jiraServers := &codebaseApi.JiraServerList{}
	if err := c.k8sClient.List(ctx, jiraServers, client.InNamespace(c.namespace)); err != nil {
		return fmt.Errorf("failed to get jira servers: %w", err)
	}

	telemetry.JiraEnabled = len(jiraServers.Items) > 0

	resp, err := resty.New().
		SetHostURL(c.telemetryUrl).
		R().
		SetContext(ctx).
		SetBody(map[string]PlatformMetrics{"platformMetrics": telemetry}).
		Post("/v1/submit")
	if err != nil {
		return fmt.Errorf("failed to send telemetry: %w", err)
	}

	if resp.IsError() {
		return fmt.Errorf("failed to send telemetry: http status code: %s, body: %s", resp.Status(), resp.String())
	}

	return nil
}