create repository during the build step and add telemetry (#3243)

api/server/handlers/registry/create_repository.go

@@ -11,6 +11,7 @@ import (
 	"github.com/porter-dev/porter/api/types"
 	"github.com/porter-dev/porter/internal/models"
 	"github.com/porter-dev/porter/internal/registry"
+	"github.com/porter-dev/porter/internal/telemetry"
 )
 
 type RegistryCreateRepositoryHandler struct {
@@ -30,12 +31,15 @@ func NewRegistryCreateRepositoryHandler(
 func (p *RegistryCreateRepositoryHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	reg, _ := ctx.Value(types.RegistryScope).(*models.Registry)
+	ctx, span := telemetry.NewSpan(r.Context(), "serve-create-repository")
+	defer span.End()
 
 	request := &types.CreateRegistryRepositoryRequest{}
 
 	ok := p.DecodeAndValidate(w, r, request)
-
 	if !ok {
+		err := telemetry.Error(ctx, span, nil, "error decoding request")
+		p.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusBadRequest))
 		return
 	}
 
@@ -45,10 +49,16 @@ func (p *RegistryCreateRepositoryHandler) ServeHTTP(w http.ResponseWriter, r *ht
 	// parse the name from the registry
 	nameSpl := strings.Split(request.ImageRepoURI, "/")
 	repoName := strings.ToLower(strings.ReplaceAll(nameSpl[len(nameSpl)-1], "_", "-"))
+	telemetry.WithAttributes(span,
+		telemetry.AttributeKV{Key: "repo-name", Value: repoName},
+		telemetry.AttributeKV{Key: "registry-id", Value: reg.ID},
+		telemetry.AttributeKV{Key: "image-repo-uri", Value: request.ImageRepoURI},
+	)
 
 	err := regAPI.CreateRepository(ctx, p.Config(), repoName)
 	if err != nil {
-		p.HandleAPIError(w, r, apierrors.NewErrInternal(err))
+		err = telemetry.Error(ctx, span, err, "error creating repository")
+		p.HandleAPIError(w, r, apierrors.NewErrPassThroughToClient(err, http.StatusInternalServerError))
 		return
 	}
 

cli/cmd/preview/build_image_driver.go

@@ -135,43 +135,42 @@ func (d *BuildDriver) Apply(resource *models.Resource) (*models.Resource, error)
 		return nil, err
 	}
 
-	if d.config.Build.UsePackCache {
-		err := config.SetDockerConfig(client)
-		if err != nil {
-			return nil, err
-		}
+	// create repository if it does not exist
+	repoResp, err := client.ListRegistryRepositories(context.Background(), d.target.Project, regID)
+	if err != nil {
+		return nil, err
+	}
 
-		if d.config.Build.Method == "pack" {
-			repoResp, err := client.ListRegistryRepositories(context.Background(), d.target.Project, regID)
-			if err != nil {
-				return nil, err
-			}
+	repos := *repoResp
 
-			repos := *repoResp
+	found := false
 
-			found := false
+	for _, repo := range repos {
+		if repo.URI == imageURL {
+			found = true
+			break
+		}
+	}
 
-			for _, repo := range repos {
-				if repo.URI == imageURL {
-					found = true
-					break
-				}
-			}
+	if !found {
+		err = client.CreateRepository(
+			context.Background(),
+			d.target.Project,
+			regID,
+			&types.CreateRegistryRepositoryRequest{
+				ImageRepoURI: imageURL,
+			},
+		)
 
-			if !found {
-				err = client.CreateRepository(
-					context.Background(),
-					d.target.Project,
-					regID,
-					&types.CreateRegistryRepositoryRequest{
-						ImageRepoURI: imageURL,
-					},
-				)
-
-				if err != nil {
-					return nil, err
-				}
-			}
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if d.config.Build.UsePackCache {
+		err := config.SetDockerConfig(client)
+		if err != nil {
+			return nil, err
 		}
 	}
 

internal/registry/registry.go

@@ -866,28 +866,42 @@ func (r *Registry) CreateRepository(
 	conf *config.Config,
 	name string,
 ) error {
+	ctx, span := telemetry.NewSpan(ctx, "create-repository")
+	defer span.End()
+
 	// if aws, create repository
 	if r.AWSIntegrationID != 0 {
+		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "aws-integration-id", Value: r.AWSIntegrationID})
 		aws, err := conf.Repo.AWSIntegration().ReadAWSIntegration(
 			r.ProjectID,
 			r.AWSIntegrationID,
 		)
 		if err != nil {
-			return err
+			return telemetry.Error(ctx, span, err, "error reading aws integration")
+		}
+		err = r.createECRRepository(aws, name)
+		if err != nil {
+			return telemetry.Error(ctx, span, err, "error creating ecr repository")
 		}
-		return r.createECRRepository(aws, name)
+		return nil
 	} else if r.GCPIntegrationID != 0 && strings.Contains(r.URL, "pkg.dev") {
-		return r.createGARRepository(ctx, conf.Repo, name)
+		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "gcp-integration-id", Value: r.GCPIntegrationID})
+		err := r.createGARRepository(ctx, conf.Repo, name)
+		if err != nil {
+			return telemetry.Error(ctx, span, err, "error creating gar repository")
+		}
+		return nil
 	}
 
 	project, err := conf.Repo.Project().ReadProject(r.ProjectID)
 	if err != nil {
-		return fmt.Errorf("error getting project for repository: %w", err)
+		return telemetry.Error(ctx, span, err, "error getting project for repository")
 	}
 
 	if project.CapiProvisionerEnabled {
 		// no need to create repository if pushing to ACR
 		if strings.Contains(r.URL, ".azurecr.") {
+			telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "skipping-create-because-azure", Value: true})
 			return nil
 		}
 
@@ -899,9 +913,10 @@ func (r *Registry) CreateRepository(
 			ProjectId:    int64(r.ProjectID),
 			AwsAccountId: accountID,
 		})
+		telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "uri", Value: uri})
 		creds, err := conf.ClusterControlPlaneClient.AssumeRoleCredentials(ctx, req)
 		if err != nil {
-			return fmt.Errorf("error getting capi credentials for repository: %w", err)
+			return telemetry.Error(ctx, span, err, "error getting capi credentials for repository")
 		}
 		aws := &ints.AWSIntegration{
 			AWSAccessKeyID:     []byte(creds.Msg.AwsAccessId),
@@ -909,7 +924,10 @@ func (r *Registry) CreateRepository(
 			AWSSessionToken:    []byte(creds.Msg.AwsSessionToken),
 			AWSRegion:          region,
 		}
-		return r.createECRRepository(aws, name)
+		err = r.createECRRepository(aws, name)
+		if err != nil {
+			return telemetry.Error(ctx, span, err, "error creating ecr repository")
+		}
 	}
 
 	// otherwise, no-op