chore: some more cleanup

pkg/query-service/app/integrations/manager.go

@@ -4,7 +4,6 @@ import (
  "context"
  "fmt"
  "slices"
- "strings"
  "time"
 
  "go.signoz.io/signoz/pkg/query-service/app/logparsingpipeline"
@@ -37,8 +36,8 @@ type IntegrationDetails struct {
  IntegrationAssets
 }
 
-type AvailableIntegration struct {
- IntegrationDetails
+type IntegrationsListItem struct {
+ IntegrationSummary
  IsInstalled bool
 }
 
@@ -49,20 +48,25 @@ type InstalledIntegration struct {
 }
 type InstalledIntegrationConfig map[string]interface{}
 
-type InstalledIntegrationWithDetails struct {
- InstalledIntegration
+type Integration struct {
  IntegrationDetails
+ Installation *InstalledIntegration
 }
 
 type Manager struct {
  availableIntegrationsRepo AvailableIntegrationsRepo
  installedIntegrationsRepo InstalledIntegrationsRepo
 }
 
-func (m *Manager) ListAvailableIntegrations(
+type IntegrationsFilter struct {
+ IsInstalled *bool
+}
+
+func (m *Manager) ListIntegrations(
  ctx context.Context,
- // Expected to have filters and pagination over time.
-) ([]AvailableIntegration, *model.ApiError) {
+ filter *IntegrationsFilter,
+ // Expected to have pagination over time.
+) ([]IntegrationsListItem, *model.ApiError) {
  available, apiErr := m.availableIntegrationsRepo.list(ctx)
  if apiErr != nil {
  return nil, model.WrapApiError(
@@ -81,81 +85,61 @@ func (m *Manager) ListAvailableIntegrations(
  installedIds = append(installedIds, ii.IntegrationId)
  }
 
- result := []AvailableIntegration{}
+ result := []IntegrationsListItem{}
  for _, ai := range available {
- result = append(result, AvailableIntegration{
- IntegrationDetails: ai,
+ result = append(result, IntegrationsListItem{
+ IntegrationSummary: ai.IntegrationSummary,
  IsInstalled: slices.Contains(installedIds, ai.Id),
  })
  }
+
+ if filter != nil {
+ if filter.IsInstalled != nil {
+ filteredResult := []IntegrationsListItem{}
+ for _, r := range result {
+ if r.IsInstalled == *filter.IsInstalled {
+ filteredResult = append(filteredResult, r)
+ }
+ }
+ result = filteredResult
+ }
+ }
+
  return result, nil
 }
 
-func (m *Manager) ListInstalledIntegrations(
+func (m *Manager) GetIntegration(
  ctx context.Context,
-) ([]InstalledIntegrationWithDetails, *model.ApiError) {
- installed, apiErr := m.installedIntegrationsRepo.list(ctx)
+ integrationId string,
+) (*Integration, *model.ApiError) {
+ integrationDetails, apiErr := m.getIntegrationDetails(
+ ctx, integrationId,
+ )
  if apiErr != nil {
- return nil, model.WrapApiError(
- apiErr, "could not fetch installed integrations",
- )
+ return nil, apiErr
  }
 
- installedIds := []string{}
- for _, ii := range installed {
- installedIds = append(installedIds, ii.IntegrationId)
- }
-
- integrationDetails, apiErr := m.availableIntegrationsRepo.get(
- ctx, installedIds,
+ installation, apiErr := m.getInstalledIntegration(
+ ctx, integrationId,
  )
  if apiErr != nil {
- return nil, model.WrapApiError(
- apiErr, "could not fetch details for installed integrations",
- )
- }
- if len(integrationDetails) != len(installedIds) {
- missingIds := []string{}
- for _, iid := range installedIds {
- if _, exists := integrationDetails[iid]; !exists {
- missingIds = append(missingIds, iid)
- }
- }
- return nil, model.NotFoundError(fmt.Errorf(
- "could not get details for all installed integrations with id: %s",
- strings.Join(missingIds, ", "),
- ))
+ return nil, apiErr
  }
 
- result := []InstalledIntegrationWithDetails{}
- for _, ii := range installed {
- result = append(result, InstalledIntegrationWithDetails{
- InstalledIntegration: ii,
- IntegrationDetails: integrationDetails[ii.IntegrationId],
- })
- }
- return result, nil
+ return &Integration{
+ IntegrationDetails: *integrationDetails,
+ Installation: installation,
+ }, nil
 }
 
 func (m *Manager) InstallIntegration(
  ctx context.Context,
  integrationId string,
  config InstalledIntegrationConfig,
-) (*AvailableIntegration, *model.ApiError) {
- ais, apiErr := m.availableIntegrationsRepo.get(
- ctx, []string{integrationId},
- )
+) (*IntegrationsListItem, *model.ApiError) {
+ integrationDetails, apiErr := m.getIntegrationDetails(ctx, integrationId)
  if apiErr != nil {
- return nil, model.WrapApiError(apiErr, fmt.Sprintf(
- "could not fetch integration to be installed: %s", integrationId,
- ))
- }
-
- integrationDetails, wasFound := ais[integrationId]
- if !wasFound {
- return nil, model.NotFoundError(fmt.Errorf(
- "could not find integration to be installed: %s", integrationId,
- ))
+ return nil, apiErr
  }
 
  _, apiErr = m.installedIntegrationsRepo.upsert(
@@ -167,8 +151,8 @@ func (m *Manager) InstallIntegration(
  )
  }
 
- return &AvailableIntegration{
- IntegrationDetails: integrationDetails,
+ return &IntegrationsListItem{
+ IntegrationSummary: integrationDetails.IntegrationSummary,
  IsInstalled: true,
  }, nil
 }
@@ -179,3 +163,46 @@ func (m *Manager) UninstallIntegration(
 ) *model.ApiError {
  return m.installedIntegrationsRepo.delete(ctx, integrationId)
 }
+
+// Helpers.
+func (m *Manager) getIntegrationDetails(
+ ctx context.Context,
+ integrationId string,
+) (*IntegrationDetails, *model.ApiError) {
+ ais, apiErr := m.availableIntegrationsRepo.get(
+ ctx, []string{integrationId},
+ )
+ if apiErr != nil {
+ return nil, model.WrapApiError(apiErr, fmt.Sprintf(
+ "could not fetch integration: %s", integrationId,
+ ))
+ }
+
+ integrationDetails, wasFound := ais[integrationId]
+ if !wasFound {
+ return nil, model.NotFoundError(fmt.Errorf(
+ "could not find integration: %s", integrationId,
+ ))
+ }
+ return &integrationDetails, nil
+}
+
+func (m *Manager) getInstalledIntegration(
+ ctx context.Context,
+ integrationId string,
+) (*InstalledIntegration, *model.ApiError) {
+ iis, apiErr := m.installedIntegrationsRepo.get(
+ ctx, []string{integrationId},
+ )
+ if apiErr != nil {
+ return nil, model.WrapApiError(apiErr, fmt.Sprintf(
+ "could not fetch installed integration: %s", integrationId,
+ ))
+ }
+
+ installation, wasFound := iis[integrationId]
+ if !wasFound {
+ return nil, nil
+ }
+ return &installation, nil
+}

pkg/query-service/app/integrations/manager_test.go

@@ -14,11 +14,18 @@ func TestIntegrationLifecycle(t *testing.T) {
  mgr := NewTestIntegrationsManager(t)
  ctx := context.Background()
 
- installedIntegrations, apiErr := mgr.ListInstalledIntegrations(ctx)
+ ii := true
+ installedIntegrationsFilter := &IntegrationsFilter{
+ IsInstalled: &ii,
+ }
+
+ installedIntegrations, apiErr := mgr.ListIntegrations(
+ ctx, installedIntegrationsFilter,
+ )
  require.Nil(apiErr)
- require.Equal([]InstalledIntegrationWithDetails{}, installedIntegrations)
+ require.Equal([]IntegrationsListItem{}, installedIntegrations)
 
- availableIntegrations, apiErr := mgr.ListAvailableIntegrations(ctx)
+ availableIntegrations, apiErr := mgr.ListIntegrations(ctx, nil)
  require.Nil(apiErr)
  require.Equal(2, len(availableIntegrations))
  require.False(availableIntegrations[0].IsInstalled)
@@ -31,12 +38,19 @@ func TestIntegrationLifecycle(t *testing.T) {
  require.Nil(apiErr)
  require.Equal(installed.Id, availableIntegrations[1].Id)
 
- installedIntegrations, apiErr = mgr.ListInstalledIntegrations(ctx)
+ integration, apiErr := mgr.GetIntegration(ctx, availableIntegrations[1].Id)
+ require.Nil(apiErr)
+ require.Equal(integration.Id, availableIntegrations[1].Id)
+ require.NotNil(integration.Installation)
+
+ installedIntegrations, apiErr = mgr.ListIntegrations(
+ ctx, installedIntegrationsFilter,
+ )
  require.Nil(apiErr)
  require.Equal(1, len(installedIntegrations))
  require.Equal(availableIntegrations[1].Id, installedIntegrations[0].Id)
 
- availableIntegrations, apiErr = mgr.ListAvailableIntegrations(ctx)
+ availableIntegrations, apiErr = mgr.ListIntegrations(ctx, nil)
  require.Nil(apiErr)
  require.Equal(2, len(availableIntegrations))
  require.False(availableIntegrations[0].IsInstalled)
@@ -45,11 +59,18 @@ func TestIntegrationLifecycle(t *testing.T) {
  apiErr = mgr.UninstallIntegration(ctx, installed.Id)
  require.Nil(apiErr)
 
- installedIntegrations, apiErr = mgr.ListInstalledIntegrations(ctx)
+ integration, apiErr = mgr.GetIntegration(ctx, availableIntegrations[1].Id)
+ require.Nil(apiErr)
+ require.Equal(integration.Id, availableIntegrations[1].Id)
+ require.Nil(integration.Installation)
+
+ installedIntegrations, apiErr = mgr.ListIntegrations(
+ ctx, installedIntegrationsFilter,
+ )
  require.Nil(apiErr)
  require.Equal(0, len(installedIntegrations))
 
- availableIntegrations, apiErr = mgr.ListAvailableIntegrations(ctx)
+ availableIntegrations, apiErr = mgr.ListIntegrations(ctx, nil)
  require.Nil(apiErr)
  require.Equal(2, len(availableIntegrations))
  require.False(availableIntegrations[0].IsInstalled)

pkg/query-service/app/integrations/test_utils.go

@@ -12,7 +12,9 @@ import (
  v3 "go.signoz.io/signoz/pkg/query-service/model/v3"
 )
 
-func NewTestIntegrationsManager(t *testing.T) *Manager {
+func NewTestSqliteDB(t *testing.T) (
+ db *sqlx.DB, dbFilePath string,
+) {
  testDBFile, err := os.CreateTemp("", "test-signoz-db-*")
  if err != nil {
  t.Fatalf("could not create temp file for test db: %v", err)
@@ -25,6 +27,13 @@ func NewTestIntegrationsManager(t *testing.T) *Manager {
  if err != nil {
  t.Fatalf("could not open test db sqlite file: %v", err)
  }
+
+ return testDB, testDBFilePath
+}
+
+func NewTestIntegrationsManager(t *testing.T) *Manager {
+ testDB, _ := NewTestSqliteDB(t)
+
  installedIntegrationsRepo, err := NewInstalledIntegrationsSqliteRepo(testDB)
  if err != nil {
  t.Fatalf("could not init sqlite DB for installed integrations: %v", err)