PMM-14700 Limit advisors to available services only (#4945)

* reduce saas package dependency

* drop tiering

* add license headers

* fix file generation

* ignore severity string file

* golang ci lint

* fix errors

* fix go-consistent

* fix alignment

* fix go-consistent

* drop logger package

* limit advisors to available services only

* replace fallthrough

* PMM-14012 drop portal connections (#4912)

* drop portal communication

* drop platform connections that are unrelated to telemetry

* mark platform fields as deprecated

* Bump anchore/sbom-action from 0.21.1 to 0.22.0 (#4952)

Bumps [anchore/sbom-action](https://github.com/anchore/sbom-action) from 0.21.1 to 0.22.0.
- [Release notes](https://github.com/anchore/sbom-action/releases)
- [Changelog](https://github.com/anchore/sbom-action/blob/main/RELEASE.md)
- [Commits](anchore/sbom-action@0b82b0b...62ad528)

---
updated-dependencies:
- dependency-name: anchore/sbom-action
  dependency-version: 0.22.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* tidy modules

* PMM-14700 Filter out only pmm-server-postgresql svc

* chore: format the code

* PMM-14700 Remove redundant comments

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Alex Demidoff <a@demidoff.me>

Author: 3 people

managed/models/service_helpers.go

@@ -162,6 +162,33 @@ func FindActiveServiceTypes(q *reform.Querier) ([]ServiceType, error) {
 	return res, nil
 }
 
+// FindActiveUserServiceTypes returns all active Service Types, excluding pmm-server-postgresql service.
+func FindActiveUserServiceTypes(q *reform.Querier) ([]ServiceType, error) {
+	query := fmt.Sprintf(`SELECT DISTINCT service_type FROM %s WHERE service_name != $1`, ServiceTable.s.SQLName)
+	rows, err := q.Query(query, PMMServerPostgreSQLServiceName)
+	if err != nil {
+		return nil, err
+	}
+
+	defer func() {
+		if rowsErr := rows.Close(); rowsErr != nil {
+			logrus.Debug(rowsErr)
+		}
+	}()
+
+	var res []ServiceType
+	for rows.Next() {
+		var serviceType ServiceType
+		if err = rows.Scan(&serviceType); err != nil {
+			return nil, err
+		}
+
+		res = append(res, serviceType)
+	}
+
+	return res, nil
+}
+
 // FindServiceByID searches Service by ID.
 func FindServiceByID(q *reform.Querier, id string) (*Service, error) {
 	if id == "" {
@@ -188,7 +215,7 @@ func FindServicesByIDs(q *reform.Querier, ids []string) (map[string]*Service, er
 
 	p := strings.Join(q.Placeholders(1, len(ids)), ", ")
 	tail := fmt.Sprintf("WHERE service_id IN (%s) ORDER BY service_id", p)
-	args := make([]interface{}, len(ids))
+	args := make([]any, len(ids))
 	for i, id := range ids {
 		args[i] = id
 	}

managed/services/checks/checks.go

@@ -600,6 +600,20 @@ func (s *Service) filterChecks(checks map[string]check.Check, group check.Interv
 	return res
 }
 
+// getActiveUserServiceTypes returns a set of service types that have at least one user-added service.
+func (s *Service) getActiveUserServiceTypes() (map[models.ServiceType]struct{}, error) {
+	serviceTypes, err := models.FindActiveUserServiceTypes(s.db.Querier)
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
+	result := make(map[models.ServiceType]struct{}, len(serviceTypes))
+	for _, st := range serviceTypes {
+		result[st] = struct{}{}
+	}
+	return result, nil
+}
+
 // executeChecks runs checks for all reachable services. If intervalGroup specified only checks from that group will be
 // executed. If checkNames specified then only matched checks will be executed.
 func (s *Service) executeChecks(ctx context.Context, intervalGroup check.Interval, checkNames []string) ([]services.CheckResult, error) {
@@ -608,24 +622,44 @@ func (s *Service) executeChecks(ctx context.Context, intervalGroup check.Interva
 		return nil, errors.WithStack(err)
 	}
 
+	activeServiceTypes, err := s.getActiveUserServiceTypes()
+	if err != nil {
+		return nil, errors.WithStack(err)
+	}
+
 	var res []services.CheckResult
 	checks, err := s.GetChecks()
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}
 	mySQLChecks, postgreSQLChecks, mongoDBChecks := groupChecksByDB(s.l, checks)
 
-	mySQLChecks = s.filterChecks(mySQLChecks, intervalGroup, disabledChecks, checkNames)
-	mySQLCheckResults := s.executeChecksForTargetType(ctx, models.MySQLServiceType, mySQLChecks)
-	res = append(res, mySQLCheckResults...)
+	// Execute MySQL checks only if MySQL services exist
+	if _, hasMySQL := activeServiceTypes[models.MySQLServiceType]; hasMySQL {
+		mySQLChecks = s.filterChecks(mySQLChecks, intervalGroup, disabledChecks, checkNames)
+		mySQLCheckResults := s.executeChecksForTargetType(ctx, models.MySQLServiceType, mySQLChecks)
+		res = append(res, mySQLCheckResults...)
+	} else {
+		s.l.Info("Skipping MySQL advisor checks: no MySQL services in inventory")
+	}
 
-	postgreSQLChecks = s.filterChecks(postgreSQLChecks, intervalGroup, disabledChecks, checkNames)
-	postgreSQLCheckResults := s.executeChecksForTargetType(ctx, models.PostgreSQLServiceType, postgreSQLChecks)
-	res = append(res, postgreSQLCheckResults...)
+	// Execute PostgreSQL checks only if PostgreSQL services exist
+	if _, hasPostgreSQL := activeServiceTypes[models.PostgreSQLServiceType]; hasPostgreSQL {
+		postgreSQLChecks = s.filterChecks(postgreSQLChecks, intervalGroup, disabledChecks, checkNames)
+		postgreSQLCheckResults := s.executeChecksForTargetType(ctx, models.PostgreSQLServiceType, postgreSQLChecks)
+		res = append(res, postgreSQLCheckResults...)
+	} else {
+		s.l.Info("Skipping PostgreSQL advisor checks: no PostgreSQL services in inventory")
+	}
 
-	mongoDBChecks = s.filterChecks(mongoDBChecks, intervalGroup, disabledChecks, checkNames)
-	mongoDBCheckResults := s.executeChecksForTargetType(ctx, models.MongoDBServiceType, mongoDBChecks)
-	res = append(res, mongoDBCheckResults...)
+	// Execute MongoDB checks only if MongoDB services exist
+	if _, hasMongoDB := activeServiceTypes[models.MongoDBServiceType]; hasMongoDB {
+		mongoDBChecks = s.filterChecks(mongoDBChecks, intervalGroup, disabledChecks, checkNames)
+		mongoDBCheckResults := s.executeChecksForTargetType(ctx, models.MongoDBServiceType, mongoDBChecks)
+		res = append(res, mongoDBCheckResults...)
+	} else {
+		s.l.Info("Skipping MongoDB advisor checks: no MongoDB services in inventory")
+	}
 
 	return res, nil
 }