msb-public
/
helm
mirror of https://github.com/helm/helm
1
0
Code Issues Projects Releases Wiki Activity

Leverage slog.Any for errors

Browse Source 
Signed-off-by: Benoit Tigeot <benoit.tigeot@lifen.fr>
pull/30708/head
Benoit Tigeot 6 months ago
parent 5c746037b3
commit 0c85456788
No known key found for this signature in database
GPG Key ID: 8E6D4FC8AEBDA62C
14 changed files with 70 additions and 65 deletions
Show Stats Download Patch File Download Diff File

2
pkg/action/action.go
Unescape View File

@ -367,7 +367,7 @@ func GetVersionSet(client discovery.ServerResourcesInterface) (chartutil.Version
// recordRelease with an update operation in case reuse has been set.
func (cfg *Configuration) recordRelease(r *release.Release) {
if err := cfg.Releases.Update(r); err != nil {
cfg.Log.Warn("failed to update release", "name", r.Name, "revision", r.Version, "error", err)
cfg.Log.Warn("failed to update release", "name", r.Name, "revision", r.Version, slog.Any("error", err))
}
}

7
pkg/action/install.go
Unescape View File

@ -21,6 +21,7 @@ import (
"context"
"fmt"
"io"
"log/slog"
"net/url"
"os"
"path"
@ -249,12 +250,12 @@ func (i *Install) RunWithContext(ctx context.Context, chrt *chart.Chart, vals ma
}
if err := i.availableName(); err != nil {
i.cfg.Log.Error("release name check failed", "error", err)
i.cfg.Log.Error("release name check failed", slog.Any("error", err))
return nil, errors.Wrap(err, "release name check failed")
}
if err := chartutil.ProcessDependencies(chrt, vals); err != nil {
i.cfg.Log.Error("chart dependencies processing failed", "error", err)
i.cfg.Log.Error("chart dependencies processing failed", slog.Any("error", err))
return nil, errors.Wrap(err, "chart dependencies processing failed")
}
@ -505,7 +506,7 @@ func (i *Install) performInstall(rel *release.Release, toBeAdopted kube.Resource
// One possible strategy would be to do a timed retry to see if we can get
// this stored in the future.
if err := i.recordRelease(rel); err != nil {
i.cfg.Log.Error("failed to record the release", "error", err)
i.cfg.Log.Error("failed to record the release", slog.Any("error", err))
}
return rel, nil

5
pkg/action/uninstall.go
Unescape View File

@ -17,6 +17,7 @@ limitations under the License.
package action
import (
"log/slog"
"strings"
"time"
@ -121,7 +122,7 @@ func (u *Uninstall) Run(name string) (*release.UninstallReleaseResponse, error)
// From here on out, the release is currently considered to be in StatusUninstalling
// state.
if err := u.cfg.Releases.Update(rel); err != nil {
u.cfg.Log.Debug("uninstall: Failed to store updated release", "error", err)
u.cfg.Log.Debug("uninstall: Failed to store updated release", slog.Any("error", err))
}
deletedResources, kept, errs := u.deleteRelease(rel)
@ -168,7 +169,7 @@ func (u *Uninstall) Run(name string) (*release.UninstallReleaseResponse, error)
}
if err := u.cfg.Releases.Update(rel); err != nil {
u.cfg.Log.Debug("uninstall: Failed to store updated release", "error", err)
u.cfg.Log.Debug("uninstall: Failed to store updated release", slog.Any("error", err))
}
if len(errs) > 0 {

3
pkg/action/upgrade.go
Unescape View File

@ -20,6 +20,7 @@ import (
"bytes"
"context"
"fmt"
"log/slog"
"strings"
"sync"
"time"
@ -486,7 +487,7 @@ func (u *Upgrade) releasingUpgrade(c chan<- resultMessage, upgradedRelease *rele
func (u *Upgrade) failRelease(rel *release.Release, created kube.ResourceList, err error) (*release.Release, error) {
msg := fmt.Sprintf("Upgrade %q failed: %s", rel.Name, err)
u.cfg.Log.Warn("upgrade failed", "name", rel.Name, "error", err)
u.cfg.Log.Warn("upgrade failed", "name", rel.Name, slog.Any("error", err))
rel.Info.Status = release.StatusFailed
rel.Info.Description = msg

2
pkg/chart/v2/util/dependencies.go
Unescape View File

@ -254,7 +254,7 @@ func processImportValues(c *chart.Chart, merge bool) error {
// get child table
vv, err := cvals.Table(r.Name + "." + child)
if err != nil {
slog.Warn("ImportValues missing table from chart", "chart", r.Name, "error", err)
slog.Warn("ImportValues missing table from chart", "chart", r.Name, slog.Any("error", err))
continue
}
// create value map from child to be merged into parent

3
pkg/cmd/search_hub.go
Unescape View File

@ -19,6 +19,7 @@ package cmd
import (
"fmt"
"io"
"log/slog"
"strings"
"github.com/gosuri/uitable"
@ -89,7 +90,7 @@ func (o *searchHubOptions) run(out io.Writer, args []string) error {
q := strings.Join(args, " ")
results, err := c.Search(q)
if err != nil {
Logger.Debug("search failed", "error", err)
Logger.Debug("search failed", slog.Any("error", err))
return fmt.Errorf("unable to perform search against %q", o.searchEndpoint)
}

3
pkg/cmd/search_repo.go
Unescape View File

@ -21,6 +21,7 @@ import (
"bytes"
"fmt"
"io"
"log/slog"
"os"
"path/filepath"
"strings"
@ -189,7 +190,7 @@ func (o *searchRepoOptions) buildIndex() (*search.Index, error) {
f := filepath.Join(o.repoCacheDir, helmpath.CacheIndexFile(n))
ind, err := repo.LoadIndexFile(f)
if err != nil {
Logger.Warn("repo is corrupt or missing", "repo", n, "error", err)
Logger.Warn("repo is corrupt or missing", "repo", n, slog.Any("error", err))
continue
}

4
pkg/engine/lookup_func.go
Unescape View File

@ -101,7 +101,7 @@ func getDynamicClientOnKind(apiversion string, kind string, config *rest.Config)
gvk := schema.FromAPIVersionAndKind(apiversion, kind)
apiRes, err := getAPIResourceForGVK(gvk, config)
if err != nil {
slog.Error("unable to get apiresource", "groupVersionKind", gvk.String(), "error", err)
slog.Error("unable to get apiresource", "groupVersionKind", gvk.String(), slog.Any("error", err))
return nil, false, errors.Wrapf(err, "unable to get apiresource from unstructured: %s", gvk.String())
}
gvr := schema.GroupVersionResource{
@ -127,7 +127,7 @@ func getAPIResourceForGVK(gvk schema.GroupVersionKind, config *rest.Config) (met
}
resList, err := discoveryClient.ServerResourcesForGroupVersion(gvk.GroupVersion().String())
if err != nil {
slog.Error("unable to retrieve resource list", "GroupVersion", gvk.GroupVersion().String(), "error", err)
slog.Error("unable to retrieve resource list", "GroupVersion", gvk.GroupVersion().String(), slog.Any("error", err))
return res, err
}
for _, resource := range resList.APIResources {

6
pkg/ignore/rules.go
Unescape View File

@ -177,7 +177,7 @@ func (r *Rules) parseRule(rule string) error {
rule = strings.TrimPrefix(rule, "/")
ok, err := filepath.Match(rule, n)
if err != nil {
slog.Error("failed to compile", "rule", rule, "error", err)
slog.Error("failed to compile", "rule", rule, slog.Any("error", err))
return false
}
return ok
@ -187,7 +187,7 @@ func (r *Rules) parseRule(rule string) error {
p.match = func(n string, _ os.FileInfo) bool {
ok, err := filepath.Match(rule, n)
if err != nil {
slog.Error("failed to compile", "rule", rule, "error", err)
slog.Error("failed to compile", "rule", rule, slog.Any("error", err))
return false
}
return ok
@ -199,7 +199,7 @@ func (r *Rules) parseRule(rule string) error {
n = filepath.Base(n)
ok, err := filepath.Match(rule, n)
if err != nil {
slog.Error("failed to compile", "rule", rule, "error", err)
slog.Error("failed to compile", "rule", rule, slog.Any("error", err))
return false
}
return ok

12
pkg/kube/client.go
Unescape View File

@ -249,7 +249,7 @@ func (c *Client) Get(resources ResourceList, related bool) (map[string][]runtime
objs, err = c.getSelectRelationPod(info, objs, isTable, &podSelectors)
if err != nil {
c.Log.Warn("get the relation pod is failed", "error", err)
c.Log.Warn("get the relation pod is failed", slog.Any("error", err))
}
}
}
@ -441,7 +441,7 @@ func (c *Client) Update(original, target ResourceList, force bool) (*Result, err
}
if err := updateResource(c, info, originalInfo.Object, force); err != nil {
c.Log.Debug("error updating the resource", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "error", err)
c.Log.Debug("error updating the resource", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, slog.Any("error", err))
updateErrors = append(updateErrors, err.Error())
}
// Because we check for errors later, append the info regardless
@ -461,19 +461,19 @@ func (c *Client) Update(original, target ResourceList, force bool) (*Result, err
c.Log.Debug("deleting resource", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind)
if err := info.Get(); err != nil {
c.Log.Debug("unable to get object", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "error", err)
c.Log.Debug("unable to get object", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, slog.Any("error", err))
continue
}
annotations, err := metadataAccessor.Annotations(info.Object)
if err != nil {
c.Log.Debug("unable to get annotations", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "error", err)
c.Log.Debug("unable to get annotations", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, slog.Any("error", err))
}
if annotations != nil && annotations[ResourcePolicyAnno] == KeepPolicy {
c.Log.Debug("skipping delete due to annotation", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "annotation", ResourcePolicyAnno, "value", KeepPolicy)
continue
}
if err := deleteResource(info, metav1.DeletePropagationBackground); err != nil {
c.Log.Debug("failed to delete resource", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "error", err)
c.Log.Debug("failed to delete resource", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, slog.Any("error", err))
continue
}
res.Deleted = append(res.Deleted, info)
@ -506,7 +506,7 @@ func rdelete(c *Client, resources ResourceList, propagation metav1.DeletionPropa
err := deleteResource(info, propagation)
if err == nil || apierrors.IsNotFound(err) {
if err != nil {
c.Log.Debug("ignoring delete failure", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "error", err)
c.Log.Debug("ignoring delete failure", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, slog.Any("error", err))
}
mtx.Lock()
defer mtx.Unlock()

4
pkg/kube/wait.go
Unescape View File

@ -104,7 +104,7 @@ func (hw *legacyWaiter) isRetryableError(err error, resource *resource.Info) boo
if err == nil {
return false
}
hw.log.Debug("error received when checking resource status", "resource", resource.Name, "error", err)
hw.log.Debug("error received when checking resource status", "resource", resource.Name, slog.Any("error", err))
if ev, ok := err.(*apierrors.StatusError); ok {
statusCode := ev.Status().Code
retryable := hw.isRetryableHTTPStatusCode(statusCode)
@ -139,7 +139,7 @@ func (hw *legacyWaiter) WaitForDelete(deleted ResourceList, timeout time.Duratio
elapsed := time.Since(startTime).Round(time.Second)
if err != nil {
hw.log.Debug("wait for resources failed", "elapsed", elapsed, "error", err)
hw.log.Debug("wait for resources failed", "elapsed", elapsed, slog.Any("error", err))
} else {
hw.log.Debug("wait for resources succeeded", "elapsed", elapsed)
}

20
pkg/storage/driver/cfgmaps.go
Unescape View File

@ -70,13 +70,13 @@ func (cfgmaps *ConfigMaps) Get(key string) (*rspb.Release, error) {
return nil, ErrReleaseNotFound
}
cfgmaps.Log.Debug("failed to get release", "key", key, "error", err)
cfgmaps.Log.Debug("failed to get release", "key", key, slog.Any("error", err))
return nil, err
}
// found the configmap, decode the base64 data string
r, err := decodeRelease(obj.Data["release"])
if err != nil {
cfgmaps.Log.Debug("failed to decode data", "key", key, "error", err)
cfgmaps.Log.Debug("failed to decode data", "key", key, slog.Any("error", err))
return nil, err
}
r.Labels = filterSystemLabels(obj.ObjectMeta.Labels)
@ -93,7 +93,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
list, err := cfgmaps.impl.List(context.Background(), opts)
if err != nil {
cfgmaps.Log.Debug("failed to list releases", "error", err)
cfgmaps.Log.Debug("failed to list releases", slog.Any("error", err))
return nil, err
}
@ -104,7 +104,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"])
if err != nil {
cfgmaps.Log.Debug("failed to decode release", "item", item, "error", err)
cfgmaps.Log.Debug("failed to decode release", "item", item, slog.Any("error", err))
continue
}
@ -132,7 +132,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
list, err := cfgmaps.impl.List(context.Background(), opts)
if err != nil {
cfgmaps.Log.Debug("failed to query with labels", "error", err)
cfgmaps.Log.Debug("failed to query with labels", slog.Any("error", err))
return nil, err
}
@ -144,7 +144,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"])
if err != nil {
cfgmaps.Log.Debug("failed to decode release", "error", err)
cfgmaps.Log.Debug("failed to decode release", slog.Any("error", err))
continue
}
rls.Labels = item.ObjectMeta.Labels
@ -166,7 +166,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
// create a new configmap to hold the release
obj, err := newConfigMapsObject(key, rls, lbs)
if err != nil {
cfgmaps.Log.Debug("failed to encode release", "name", rls.Name, "error", err)
cfgmaps.Log.Debug("failed to encode release", "name", rls.Name, slog.Any("error", err))
return err
}
// push the configmap object out into the kubiverse
@ -175,7 +175,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
return ErrReleaseExists
}
cfgmaps.Log.Debug("failed to create release", "error", err)
cfgmaps.Log.Debug("failed to create release", slog.Any("error", err))
return err
}
return nil
@ -194,13 +194,13 @@ func (cfgmaps *ConfigMaps) Update(key string, rls *rspb.Release) error {
// create a new configmap object to hold the release
obj, err := newConfigMapsObject(key, rls, lbs)
if err != nil {
cfgmaps.Log.Debug("failed to encode release", "name", rls.Name, "error", err)
cfgmaps.Log.Debug("failed to encode release", "name", rls.Name, slog.Any("error", err))
return err
}
// push the configmap object out into the kubiverse
_, err = cfgmaps.impl.Update(context.Background(), obj, metav1.UpdateOptions{})
if err != nil {
cfgmaps.Log.Debug("failed to update release", "error", err)
cfgmaps.Log.Debug("failed to update release", slog.Any("error", err))
return err
}
return nil

4
pkg/storage/driver/secrets.go
Unescape View File

@ -96,7 +96,7 @@ func (secrets *Secrets) List(filter func(*rspb.Release) bool) ([]*rspb.Release,
for _, item := range list.Items {
rls, err := decodeRelease(string(item.Data["release"]))
if err != nil {
secrets.Log.Debug("list failed to decode release", "key", item.Name, "error", err)
secrets.Log.Debug("list failed to decode release", "key", item.Name, slog.Any("error", err))
continue
}
@ -135,7 +135,7 @@ func (secrets *Secrets) Query(labels map[string]string) ([]*rspb.Release, error)
for _, item := range list.Items {
rls, err := decodeRelease(string(item.Data["release"]))
if err != nil {
secrets.Log.Debug("failed to decode release", "key", item.Name, "error", err)
secrets.Log.Debug("failed to decode release", "key", item.Name, slog.Any("error", err))
continue
}
rls.Labels = item.ObjectMeta.Labels

60
pkg/storage/driver/sql.go
Unescape View File

@ -109,7 +109,7 @@ func (s *SQL) checkAlreadyApplied(migrations []*migrate.Migration) bool {
records, err := migrate.GetMigrationRecords(s.db.DB, postgreSQLDialect)
migrate.SetDisableCreateTable(false)
if err != nil {
s.Log.Debug("failed to get migration records", "error", err)
s.Log.Debug("failed to get migration records", slog.Any("error", err))
return false
}
@ -310,24 +310,24 @@ func (s *SQL) Get(key string) (*rspb.Release, error) {
query, args, err := qb.ToSql()
if err != nil {
s.Log.Debug("failed to build query", "error", err)
s.Log.Debug("failed to build query", slog.Any("error", err))
return nil, err
}
// Get will return an error if the result is empty
if err := s.db.Get(&record, query, args...); err != nil {
s.Log.Debug("got SQL error when getting release", "key", key, "error", err)
s.Log.Debug("got SQL error when getting release", "key", key, slog.Any("error", err))
return nil, ErrReleaseNotFound
}
release, err := decodeRelease(record.Body)
if err != nil {
s.Log.Debug("failed to decode data", "key", key, "error", err)
s.Log.Debug("failed to decode data", "key", key, slog.Any("error", err))
return nil, err
}
if release.Labels, err = s.getReleaseCustomLabels(key, s.namespace); err != nil {
s.Log.Debug("failed to get release custom labels", "namespace", s.namespace, "key", key, "error", err)
s.Log.Debug("failed to get release custom labels", "namespace", s.namespace, "key", key, slog.Any("error", err))
return nil, err
}
@ -348,13 +348,13 @@ func (s *SQL) List(filter func(*rspb.Release) bool) ([]*rspb.Release, error) {
query, args, err := sb.ToSql()
if err != nil {
s.Log.Debug("failed to build query", "error", err)
s.Log.Debug("failed to build query", slog.Any("error", err))
return nil, err
}
var records = []SQLReleaseWrapper{}
if err := s.db.Select(&records, query, args...); err != nil {
s.Log.Debug("failed to list", "error", err)
s.Log.Debug("failed to list", slog.Any("error", err))
return nil, err
}
@ -362,12 +362,12 @@ func (s *SQL) List(filter func(*rspb.Release) bool) ([]*rspb.Release, error) {
for _, record := range records {
release, err := decodeRelease(record.Body)
if err != nil {
s.Log.Debug("failed to decode release", "record", record, "error", err)
s.Log.Debug("failed to decode release", "record", record, slog.Any("error", err))
continue
}
if release.Labels, err = s.getReleaseCustomLabels(record.Key, record.Namespace); err != nil {
s.Log.Debug("failed to get release custom labels", "namespace", record.Namespace, "key", record.Key, "error", err)
s.Log.Debug("failed to get release custom labels", "namespace", record.Namespace, "key", record.Key, slog.Any("error", err))
return nil, err
}
for k, v := range getReleaseSystemLabels(release) {
@ -410,13 +410,13 @@ func (s *SQL) Query(labels map[string]string) ([]*rspb.Release, error) {
// Build our query
query, args, err := sb.ToSql()
if err != nil {
s.Log.Debug("failed to build query", "error", err)
s.Log.Debug("failed to build query", slog.Any("error", err))
return nil, err
}
var records = []SQLReleaseWrapper{}
if err := s.db.Select(&records, query, args...); err != nil {
s.Log.Debug("failed to query with labels", "error", err)
s.Log.Debug("failed to query with labels", slog.Any("error", err))
return nil, err
}
@ -428,12 +428,12 @@ func (s *SQL) Query(labels map[string]string) ([]*rspb.Release, error) {
for _, record := range records {
release, err := decodeRelease(record.Body)
if err != nil {
s.Log.Debug("failed to decode release", "record", record, "error", err)
s.Log.Debug("failed to decode release", "record", record, slog.Any("error", err))
continue
}
if release.Labels, err = s.getReleaseCustomLabels(record.Key, record.Namespace); err != nil {
s.Log.Debug("failed to get release custom labels", "namespace", record.Namespace, "key", record.Key, "error", err)
s.Log.Debug("failed to get release custom labels", "namespace", record.Namespace, "key", record.Key, slog.Any("error", err))
return nil, err
}
@ -457,13 +457,13 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
body, err := encodeRelease(rls)
if err != nil {
s.Log.Debug("failed to encode release", "error", err)
s.Log.Debug("failed to encode release", slog.Any("error", err))
return err
}
transaction, err := s.db.Beginx()
if err != nil {
s.Log.Debug("failed to start SQL transaction", "error", err)
s.Log.Debug("failed to start SQL transaction", slog.Any("error", err))
return fmt.Errorf("error beginning transaction: %v", err)
}
@ -492,7 +492,7 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
int(time.Now().Unix()),
).ToSql()
if err != nil {
s.Log.Debug("failed to build insert query", "error", err)
s.Log.Debug("failed to build insert query", slog.Any("error", err))
return err
}
@ -516,7 +516,7 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
return ErrReleaseExists
}
s.Log.Debug("failed to store release in SQL database", "key", key, "error", err)
s.Log.Debug("failed to store release in SQL database", "key", key, slog.Any("error", err))
return err
}
@ -539,13 +539,13 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
if err != nil {
defer transaction.Rollback()
s.Log.Debug("failed to build insert query", "error", err)
s.Log.Debug("failed to build insert query", slog.Any("error", err))
return err
}
if _, err := transaction.Exec(insertLabelsQuery, args...); err != nil {
defer transaction.Rollback()
s.Log.Debug("failed to write Labels", "error", err)
s.Log.Debug("failed to write Labels", slog.Any("error", err))
return err
}
}
@ -564,7 +564,7 @@ func (s *SQL) Update(key string, rls *rspb.Release) error {
body, err := encodeRelease(rls)
if err != nil {
s.Log.Debug("failed to encode release", "error", err)
s.Log.Debug("failed to encode release", slog.Any("error", err))
return err
}
@ -581,12 +581,12 @@ func (s *SQL) Update(key string, rls *rspb.Release) error {
ToSql()
if err != nil {
s.Log.Debug("failed to build update query", "error", err)
s.Log.Debug("failed to build update query", slog.Any("error", err))
return err
}
if _, err := s.db.Exec(query, args...); err != nil {
s.Log.Debug("failed to update release in SQL database", "key", key, "error", err)
s.Log.Debug("failed to update release in SQL database", "key", key, slog.Any("error", err))
return err
}
@ -597,7 +597,7 @@ func (s *SQL) Update(key string, rls *rspb.Release) error {
func (s *SQL) Delete(key string) (*rspb.Release, error) {
transaction, err := s.db.Beginx()
if err != nil {
s.Log.Debug("failed to start SQL transaction", "error", err)
s.Log.Debug("failed to start SQL transaction", slog.Any("error", err))
return nil, fmt.Errorf("error beginning transaction: %v", err)
}
@ -608,20 +608,20 @@ func (s *SQL) Delete(key string) (*rspb.Release, error) {
Where(sq.Eq{sqlReleaseTableNamespaceColumn: s.namespace}).
ToSql()
if err != nil {
s.Log.Debug("failed to build select query", "error", err)
s.Log.Debug("failed to build select query", slog.Any("error", err))
return nil, err
}
var record SQLReleaseWrapper
err = transaction.Get(&record, selectQuery, args...)
if err != nil {
s.Log.Debug("release not found", "key", key, "error", err)
s.Log.Debug("release not found", "key", key, slog.Any("error", err))
return nil, ErrReleaseNotFound
}
release, err := decodeRelease(record.Body)
if err != nil {
s.Log.Debug("failed to decode release", "key", key, "error", err)
s.Log.Debug("failed to decode release", "key", key, slog.Any("error", err))
transaction.Rollback()
return nil, err
}
@ -633,18 +633,18 @@ func (s *SQL) Delete(key string) (*rspb.Release, error) {
Where(sq.Eq{sqlReleaseTableNamespaceColumn: s.namespace}).
ToSql()
if err != nil {
s.Log.Debug("failed to build delete query", "error", err)
s.Log.Debug("failed to build delete query", slog.Any("error", err))
return nil, err
}
_, err = transaction.Exec(deleteQuery, args...)
if err != nil {
s.Log.Debug("failed perform delete query", "error", err)
s.Log.Debug("failed perform delete query", slog.Any("error", err))
return release, err
}
if release.Labels, err = s.getReleaseCustomLabels(key, s.namespace); err != nil {
s.Log.Debug("failed to get release custom labels", "namespace", s.namespace, "key", key, "error", err)
s.Log.Debug("failed to get release custom labels", "namespace", s.namespace, "key", key, slog.Any("error", err))
return nil, err
}
@ -655,7 +655,7 @@ func (s *SQL) Delete(key string) (*rspb.Release, error) {
ToSql()
if err != nil {
s.Log.Debug("failed to build delete Labels query", "error", err)
s.Log.Debug("failed to build delete Labels query", slog.Any("error", err))
return nil, err
}
_, err = transaction.Exec(deleteCustomLabelsQuery, args...)

Write Preview
Loading…
Cancel
Save