func()

in pkg/analyzer/ReportAnalyzer.go [99:220]
100 lines of code
25 McCabe index (conditional complexity)

func (t *ReportAnalyzer) Analyze(data []byte, extraData model.ExtraData) error {
	if t.analyzeContext.Err() != nil {
		return nil
	}

	var err error

	runResult := &RunResult{
		RawReport: data,

		TcBuildId:          getNullIfEmpty(extraData.TcBuildId),
		TcBuildType:        extraData.TcBuildType,
		TcInstallerBuildId: getNullIfEmpty(extraData.TcInstallerBuildId),
		ReportFileName:     extraData.ReportFile,
		TriggeredBy:        extraData.TriggeredBy,
	}

	if isBisectRun(extraData, t.logger) {
		return nil
	}

	switch t.config.DbName {
	case "jbr":
		ignore := analyzePerfJbrReport(runResult, extraData)
		if ignore {
			// ignore empty report
			return nil
		}
	case "qodana":
		reportURL := runResult.ReportFileName
		fileName := reportURL[strings.LastIndex(reportURL, "/")+1:]
		if fileName == "open-telemetry.json" {
			ignore := analyzeQodanaReport(runResult, extraData)
			if ignore {
				return nil
			}
		}
		if fileName == "metrics.json" {
			err = ReadReport(runResult, t.config)
		}

	default:
		err = ReadReport(runResult, t.config)
	}
	projectId := t.config.DbName
	if err != nil {
		return err
	}

	if runResult.Report == nil {
		// ignore report
		return nil
	}

	if extraData.ProductCode == "" {
		extraData.ProductCode = runResult.Report.ProductCode
	}
	if extraData.BuildNumber == "" {
		extraData.BuildNumber = runResult.Report.Build
	}

	if extraData.Machine == "" {
		return errors.New("machine is not specified")
	}

	runResult.Product = extraData.ProductCode
	runResult.Machine = extraData.Machine

	if runResult.GeneratedTime.IsZero() {
		runResult.GeneratedTime, err = computeGeneratedTime(runResult.Report, extraData)
		if err != nil {
			if extraData.CurrentBuildTime.IsZero() {
				return err
			}
			runResult.GeneratedTime = extraData.CurrentBuildTime
		}
	}

	if t.config.HasInstallerField {
		runResult.BuildTime = extraData.BuildTime

		if extraData.BuildNumber == "" {
			t.logger.Error("buildNumber is missed")
			return nil
		}

		buildComponents := strings.Split(extraData.BuildNumber, ".")
		if len(buildComponents) == 2 {
			buildComponents = append(buildComponents, "0")
		}

		runResult.BuildC1, runResult.BuildC2, runResult.BuildC3, err = splitBuildNumber(buildComponents)
		if err != nil {
			// we might get 231.snapshot build numbers, that is more or less fine and we need such build anyway
			t.logger.Error(err.Error())
		}
	}

	if t.config.HasBuildNumber {
		runResult.BuildNumber = extraData.TcBuildNumber
	}

	if t.analyzeContext.Err() != nil {
		return nil
	}

	if len(extraData.TcBuildProperties) == 0 {
		runResult.branch = "master"
	} else {
		runResult.branch, err = getBranch(runResult, extraData, projectId, t.logger)
		if err != nil {
			return err
		}
	}

	t.waitGroup.Add(1)
	t.insertQueue <- &ReportInfo{
		extraData: extraData,
		runResult: runResult,
	}
	return nil
}