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. // recordRelease with an update operation in case reuse has been set.
func (cfg *Configuration) recordRelease(r *release.Release) { func (cfg *Configuration) recordRelease(r *release.Release) {
if err := cfg.Releases.Update(r); err != nil { 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" "context"
"fmt" "fmt"
"io" "io"
"log/slog"
"net/url" "net/url"
"os" "os"
"path" "path"
@ -249,12 +250,12 @@ func (i *Install) RunWithContext(ctx context.Context, chrt *chart.Chart, vals ma
} }
if err := i.availableName(); err != nil { 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") return nil, errors.Wrap(err, "release name check failed")
} }
if err := chartutil.ProcessDependencies(chrt, vals); err != nil { 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") 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 // One possible strategy would be to do a timed retry to see if we can get
// this stored in the future. // this stored in the future.
if err := i.recordRelease(rel); err != nil { 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 return rel, nil

5
pkg/action/uninstall.go
Unescape View File

@ -17,6 +17,7 @@ limitations under the License.
package action package action
import ( import (
"log/slog"
"strings" "strings"
"time" "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 // From here on out, the release is currently considered to be in StatusUninstalling
// state. // state.
if err := u.cfg.Releases.Update(rel); err != nil { 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) 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 { 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 { if len(errs) > 0 {

3
pkg/action/upgrade.go
Unescape View File

@ -20,6 +20,7 @@ import (
"bytes" "bytes"
"context" "context"
"fmt" "fmt"
"log/slog"
"strings" "strings"
"sync" "sync"
"time" "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) { 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) 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.Status = release.StatusFailed
rel.Info.Description = msg 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 // get child table
vv, err := cvals.Table(r.Name + "." + child) vv, err := cvals.Table(r.Name + "." + child)
if err != nil { 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 continue
} }
// create value map from child to be merged into parent // 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 ( import (
"fmt" "fmt"
"io" "io"
"log/slog"
"strings" "strings"
"github.com/gosuri/uitable" "github.com/gosuri/uitable"
@ -89,7 +90,7 @@ func (o *searchHubOptions) run(out io.Writer, args []string) error {
q := strings.Join(args, " ") q := strings.Join(args, " ")
results, err := c.Search(q) results, err := c.Search(q)
if err != nil { 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) 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" "bytes"
"fmt" "fmt"
"io" "io"
"log/slog"
"os" "os"
"path/filepath" "path/filepath"
"strings" "strings"
@ -189,7 +190,7 @@ func (o *searchRepoOptions) buildIndex() (*search.Index, error) {
f := filepath.Join(o.repoCacheDir, helmpath.CacheIndexFile(n)) f := filepath.Join(o.repoCacheDir, helmpath.CacheIndexFile(n))
ind, err := repo.LoadIndexFile(f) ind, err := repo.LoadIndexFile(f)
if err != nil { 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 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) gvk := schema.FromAPIVersionAndKind(apiversion, kind)
apiRes, err := getAPIResourceForGVK(gvk, config) apiRes, err := getAPIResourceForGVK(gvk, config)
if err != nil { 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()) return nil, false, errors.Wrapf(err, "unable to get apiresource from unstructured: %s", gvk.String())
} }
gvr := schema.GroupVersionResource{ gvr := schema.GroupVersionResource{
@ -127,7 +127,7 @@ func getAPIResourceForGVK(gvk schema.GroupVersionKind, config *rest.Config) (met
} }
resList, err := discoveryClient.ServerResourcesForGroupVersion(gvk.GroupVersion().String()) resList, err := discoveryClient.ServerResourcesForGroupVersion(gvk.GroupVersion().String())
if err != nil { 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 return res, err
} }
for _, resource := range resList.APIResources { 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, "/") rule = strings.TrimPrefix(rule, "/")
ok, err := filepath.Match(rule, n) ok, err := filepath.Match(rule, n)
if err != nil { 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 false
} }
return ok return ok
@ -187,7 +187,7 @@ func (r *Rules) parseRule(rule string) error {
p.match = func(n string, _ os.FileInfo) bool { p.match = func(n string, _ os.FileInfo) bool {
ok, err := filepath.Match(rule, n) ok, err := filepath.Match(rule, n)
if err != nil { 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 false
} }
return ok return ok
@ -199,7 +199,7 @@ func (r *Rules) parseRule(rule string) error {
n = filepath.Base(n) n = filepath.Base(n)
ok, err := filepath.Match(rule, n) ok, err := filepath.Match(rule, n)
if err != nil { 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 false
} }
return ok 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) objs, err = c.getSelectRelationPod(info, objs, isTable, &podSelectors)
if err != nil { 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 { 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()) updateErrors = append(updateErrors, err.Error())
} }
// Because we check for errors later, append the info regardless // 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) c.Log.Debug("deleting resource", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind)
if err := info.Get(); err != nil { 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 continue
} }
annotations, err := metadataAccessor.Annotations(info.Object) annotations, err := metadataAccessor.Annotations(info.Object)
if err != nil { 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 { 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) c.Log.Debug("skipping delete due to annotation", "namespace", info.Namespace, "name", info.Name, "kind", info.Mapping.GroupVersionKind.Kind, "annotation", ResourcePolicyAnno, "value", KeepPolicy)
continue continue
} }
if err := deleteResource(info, metav1.DeletePropagationBackground); err != nil { 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 continue
} }
res.Deleted = append(res.Deleted, info) res.Deleted = append(res.Deleted, info)
@ -506,7 +506,7 @@ func rdelete(c *Client, resources ResourceList, propagation metav1.DeletionPropa
err := deleteResource(info, propagation) err := deleteResource(info, propagation)
if err == nil || apierrors.IsNotFound(err) { if err == nil || apierrors.IsNotFound(err) {
if err != nil { 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() mtx.Lock()
defer mtx.Unlock() 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 { if err == nil {
return false 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 { if ev, ok := err.(*apierrors.StatusError); ok {
statusCode := ev.Status().Code statusCode := ev.Status().Code
retryable := hw.isRetryableHTTPStatusCode(statusCode) retryable := hw.isRetryableHTTPStatusCode(statusCode)
@ -139,7 +139,7 @@ func (hw *legacyWaiter) WaitForDelete(deleted ResourceList, timeout time.Duratio
elapsed := time.Since(startTime).Round(time.Second) elapsed := time.Since(startTime).Round(time.Second)
if err != nil { 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 { } else {
hw.log.Debug("wait for resources succeeded", "elapsed", elapsed) 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 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 return nil, err
} }
// found the configmap, decode the base64 data string // found the configmap, decode the base64 data string
r, err := decodeRelease(obj.Data["release"]) r, err := decodeRelease(obj.Data["release"])
if err != nil { 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 return nil, err
} }
r.Labels = filterSystemLabels(obj.ObjectMeta.Labels) 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) list, err := cfgmaps.impl.List(context.Background(), opts)
if err != nil { 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 return nil, err
} }
@ -104,7 +104,7 @@ func (cfgmaps *ConfigMaps) List(filter func(*rspb.Release) bool) ([]*rspb.Releas
for _, item := range list.Items { for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"]) rls, err := decodeRelease(item.Data["release"])
if err != nil { 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 continue
} }
@ -132,7 +132,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
list, err := cfgmaps.impl.List(context.Background(), opts) list, err := cfgmaps.impl.List(context.Background(), opts)
if err != nil { 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 return nil, err
} }
@ -144,7 +144,7 @@ func (cfgmaps *ConfigMaps) Query(labels map[string]string) ([]*rspb.Release, err
for _, item := range list.Items { for _, item := range list.Items {
rls, err := decodeRelease(item.Data["release"]) rls, err := decodeRelease(item.Data["release"])
if err != nil { if err != nil {
cfgmaps.Log.Debug("failed to decode release", "error", err) cfgmaps.Log.Debug("failed to decode release", slog.Any("error", err))
continue continue
} }
rls.Labels = item.ObjectMeta.Labels 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 // create a new configmap to hold the release
obj, err := newConfigMapsObject(key, rls, lbs) obj, err := newConfigMapsObject(key, rls, lbs)
if err != nil { 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 return err
} }
// push the configmap object out into the kubiverse // push the configmap object out into the kubiverse
@ -175,7 +175,7 @@ func (cfgmaps *ConfigMaps) Create(key string, rls *rspb.Release) error {
return ErrReleaseExists 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 err
} }
return nil 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 // create a new configmap object to hold the release
obj, err := newConfigMapsObject(key, rls, lbs) obj, err := newConfigMapsObject(key, rls, lbs)
if err != nil { 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 return err
} }
// push the configmap object out into the kubiverse // push the configmap object out into the kubiverse
_, err = cfgmaps.impl.Update(context.Background(), obj, metav1.UpdateOptions{}) _, err = cfgmaps.impl.Update(context.Background(), obj, metav1.UpdateOptions{})
if err != nil { 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 err
} }
return nil 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 { for _, item := range list.Items {
rls, err := decodeRelease(string(item.Data["release"])) rls, err := decodeRelease(string(item.Data["release"]))
if err != nil { 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 continue
} }
@ -135,7 +135,7 @@ func (secrets *Secrets) Query(labels map[string]string) ([]*rspb.Release, error)
for _, item := range list.Items { for _, item := range list.Items {
rls, err := decodeRelease(string(item.Data["release"])) rls, err := decodeRelease(string(item.Data["release"]))
if err != nil { 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 continue
} }
rls.Labels = item.ObjectMeta.Labels 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) records, err := migrate.GetMigrationRecords(s.db.DB, postgreSQLDialect)
migrate.SetDisableCreateTable(false) migrate.SetDisableCreateTable(false)
if err != nil { 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 return false
} }
@ -310,24 +310,24 @@ func (s *SQL) Get(key string) (*rspb.Release, error) {
query, args, err := qb.ToSql() query, args, err := qb.ToSql()
if err != nil { 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 return nil, err
} }
// Get will return an error if the result is empty // Get will return an error if the result is empty
if err := s.db.Get(&record, query, args...); err != nil { 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 return nil, ErrReleaseNotFound
} }
release, err := decodeRelease(record.Body) release, err := decodeRelease(record.Body)
if err != nil { 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 return nil, err
} }
if release.Labels, err = s.getReleaseCustomLabels(key, s.namespace); err != nil { 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 return nil, err
} }
@ -348,13 +348,13 @@ func (s *SQL) List(filter func(*rspb.Release) bool) ([]*rspb.Release, error) {
query, args, err := sb.ToSql() query, args, err := sb.ToSql()
if err != nil { 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 return nil, err
} }
var records = []SQLReleaseWrapper{} var records = []SQLReleaseWrapper{}
if err := s.db.Select(&records, query, args...); err != nil { 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 return nil, err
} }
@ -362,12 +362,12 @@ func (s *SQL) List(filter func(*rspb.Release) bool) ([]*rspb.Release, error) {
for _, record := range records { for _, record := range records {
release, err := decodeRelease(record.Body) release, err := decodeRelease(record.Body)
if err != nil { 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 continue
} }
if release.Labels, err = s.getReleaseCustomLabels(record.Key, record.Namespace); err != nil { 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 return nil, err
} }
for k, v := range getReleaseSystemLabels(release) { for k, v := range getReleaseSystemLabels(release) {
@ -410,13 +410,13 @@ func (s *SQL) Query(labels map[string]string) ([]*rspb.Release, error) {
// Build our query // Build our query
query, args, err := sb.ToSql() query, args, err := sb.ToSql()
if err != nil { 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 return nil, err
} }
var records = []SQLReleaseWrapper{} var records = []SQLReleaseWrapper{}
if err := s.db.Select(&records, query, args...); err != nil { 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 return nil, err
} }
@ -428,12 +428,12 @@ func (s *SQL) Query(labels map[string]string) ([]*rspb.Release, error) {
for _, record := range records { for _, record := range records {
release, err := decodeRelease(record.Body) release, err := decodeRelease(record.Body)
if err != nil { 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 continue
} }
if release.Labels, err = s.getReleaseCustomLabels(record.Key, record.Namespace); err != nil { 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 return nil, err
} }
@ -457,13 +457,13 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
body, err := encodeRelease(rls) body, err := encodeRelease(rls)
if err != nil { 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 return err
} }
transaction, err := s.db.Beginx() transaction, err := s.db.Beginx()
if err != nil { 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) 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()), int(time.Now().Unix()),
).ToSql() ).ToSql()
if err != nil { 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 return err
} }
@ -516,7 +516,7 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
return ErrReleaseExists 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 return err
} }
@ -539,13 +539,13 @@ func (s *SQL) Create(key string, rls *rspb.Release) error {
if err != nil { if err != nil {
defer transaction.Rollback() 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 return err
} }
if _, err := transaction.Exec(insertLabelsQuery, args...); err != nil { if _, err := transaction.Exec(insertLabelsQuery, args...); err != nil {
defer transaction.Rollback() 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 return err
} }
} }
@ -564,7 +564,7 @@ func (s *SQL) Update(key string, rls *rspb.Release) error {
body, err := encodeRelease(rls) body, err := encodeRelease(rls)
if err != nil { 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 return err
} }
@ -581,12 +581,12 @@ func (s *SQL) Update(key string, rls *rspb.Release) error {
ToSql() ToSql()
if err != nil { 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 return err
} }
if _, err := s.db.Exec(query, args...); err != nil { 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 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) { func (s *SQL) Delete(key string) (*rspb.Release, error) {
transaction, err := s.db.Beginx() transaction, err := s.db.Beginx()
if err != nil { 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) 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}). Where(sq.Eq{sqlReleaseTableNamespaceColumn: s.namespace}).
ToSql() ToSql()
if err != nil { 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 return nil, err
} }
var record SQLReleaseWrapper var record SQLReleaseWrapper
err = transaction.Get(&record, selectQuery, args...) err = transaction.Get(&record, selectQuery, args...)
if err != nil { 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 return nil, ErrReleaseNotFound
} }
release, err := decodeRelease(record.Body) release, err := decodeRelease(record.Body)
if err != nil { 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() transaction.Rollback()
return nil, err return nil, err
} }
@ -633,18 +633,18 @@ func (s *SQL) Delete(key string) (*rspb.Release, error) {
Where(sq.Eq{sqlReleaseTableNamespaceColumn: s.namespace}). Where(sq.Eq{sqlReleaseTableNamespaceColumn: s.namespace}).
ToSql() ToSql()
if err != nil { 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 return nil, err
} }
_, err = transaction.Exec(deleteQuery, args...) _, err = transaction.Exec(deleteQuery, args...)
if err != nil { 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 return release, err
} }
if release.Labels, err = s.getReleaseCustomLabels(key, s.namespace); err != nil { 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 return nil, err
} }
@ -655,7 +655,7 @@ func (s *SQL) Delete(key string) (*rspb.Release, error) {
ToSql() ToSql()
if err != nil { 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 return nil, err
} }
_, err = transaction.Exec(deleteCustomLabelsQuery, args...) _, err = transaction.Exec(deleteCustomLabelsQuery, args...)

Write Preview
Loading…
Cancel
Save