From 3b6c91526d5fae484145198c6a8963e347d9a329 Mon Sep 17 00:00:00 2001 From: Matt Moore Date: Wed, 18 Sep 2024 15:45:20 -0700 Subject: [PATCH] Stream events directly to GCS This takes a fairly different approach to how we emit our logs to GCS. Previously we received them in one container and wrote them out to the local filesystem, and a sidecar would periodically enumerate the files emitted by that process, concatenate them, and send them up to GCS in a single upload. When we shifted to Cloud Run, this approach became problematic because the filesystem is backed by memory, so under heavy load the event handler could see a lot of memory pressure between rotations and between the filesystem and the concatenation for the upload they end up in memory twice. By collapsing the two processes together and simply uploading things directly, we can initiate a new file write, trickle events to that writer, and then flush the active writers. Worst case the client is dumb and buffers things once, but in a perfect world this would initiate an upload of unknown size and we would stream events as they come in, which would dramatically reduce our memory pressure to roughly O(active events). Signed-off-by: Matt Moore --- modules/cloudevent-recorder/README.md | 2 +- .../cloudevent-recorder/cmd/logrotate/main.go | 36 --- .../cloudevent-recorder/cmd/recorder/main.go | 87 ++++++- modules/cloudevent-recorder/recorder.tf | 43 +--- modules/cloudevent-recorder/variables.tf | 2 +- pkg/rotate/blob.go | 195 -------------- pkg/rotate/blob_test.go | 242 ------------------ pkg/rotate/testdata/long_event_line.json | 2 - 8 files changed, 86 insertions(+), 523 deletions(-) delete mode 100644 modules/cloudevent-recorder/cmd/logrotate/main.go delete mode 100644 pkg/rotate/blob.go delete mode 100644 pkg/rotate/blob_test.go delete mode 100644 pkg/rotate/testdata/long_event_line.json diff --git a/modules/cloudevent-recorder/README.md b/modules/cloudevent-recorder/README.md index c1911636..bbf817ec 100644 --- a/modules/cloudevent-recorder/README.md +++ b/modules/cloudevent-recorder/README.md @@ -136,7 +136,7 @@ No requirements. | [cloud\_storage\_config\_max\_duration](#input\_cloud\_storage\_config\_max\_duration) | The maximum duration that can elapse before a new Cloud Storage file is created. Min 1 minute, max 10 minutes, default 5 minutes. | `number` | `300` | no | | [deletion\_protection](#input\_deletion\_protection) | Whether to enable deletion protection on data resources. | `bool` | `true` | no | | [enable\_profiler](#input\_enable\_profiler) | Enable cloud profiler. | `bool` | `false` | no | -| [flush\_interval](#input\_flush\_interval) | Flush interval for logrotate, as a duration string. | `string` | `""` | no | +| [flush\_interval](#input\_flush\_interval) | Flush interval for logrotate, as a duration string. | `string` | `"3m"` | no | | [ignore\_unknown\_values](#input\_ignore\_unknown\_values) | Whether to ignore unknown values in the data, when transferring data to BigQuery. | `bool` | `false` | no | | [limits](#input\_limits) | Resource limits for the regional go service. | 
object({
    cpu    = string
    memory = string
  })
| `null` | no | | [location](#input\_location) | The location to create the BigQuery dataset in, and in which to run the data transfer jobs from GCS. | `string` | `"US"` | no | diff --git a/modules/cloudevent-recorder/cmd/logrotate/main.go b/modules/cloudevent-recorder/cmd/logrotate/main.go deleted file mode 100644 index 61e5f2b5..00000000 --- a/modules/cloudevent-recorder/cmd/logrotate/main.go +++ /dev/null @@ -1,36 +0,0 @@ -/* -Copyright 2023 Chainguard, Inc. -SPDX-License-Identifier: Apache-2.0 -*/ - -package main - -import ( - "context" - "os" - "os/signal" - "time" - - "github.com/chainguard-dev/clog" - _ "github.com/chainguard-dev/clog/gcp/init" - "github.com/chainguard-dev/terraform-infra-common/pkg/rotate" - "github.com/sethvargo/go-envconfig" - - "syscall" -) - -var env = envconfig.MustProcess(context.Background(), &struct { - Bucket string `env:"BUCKET, required"` - FlushInterval time.Duration `env:"FLUSH_INTERVAL, default=3m"` - LogPath string `env:"LOG_PATH, required"` -}{}) - -func main() { - uploader := rotate.NewUploader(env.LogPath, env.Bucket, env.FlushInterval) - - ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM) - defer cancel() - if err := uploader.Run(ctx); err != nil { - clog.Fatalf("Failed to run the uploader: %v", err) - } -} diff --git a/modules/cloudevent-recorder/cmd/recorder/main.go b/modules/cloudevent-recorder/cmd/recorder/main.go index d1d766a3..09c73a99 100644 --- a/modules/cloudevent-recorder/cmd/recorder/main.go +++ b/modules/cloudevent-recorder/cmd/recorder/main.go @@ -10,21 +10,29 @@ import ( "os" "os/signal" "path/filepath" + "strconv" + "sync" "syscall" + "time" cloudevents "github.com/cloudevents/sdk-go/v2" "github.com/sethvargo/go-envconfig" + "gocloud.dev/blob" "github.com/chainguard-dev/clog" _ "github.com/chainguard-dev/clog/gcp/init" "github.com/chainguard-dev/terraform-infra-common/pkg/httpmetrics" mce "github.com/chainguard-dev/terraform-infra-common/pkg/httpmetrics/cloudevents" "github.com/chainguard-dev/terraform-infra-common/pkg/profiler" + + // Add gcsblob support that we need to support gs:// prefixes + _ "gocloud.dev/blob/gcsblob" ) var env = envconfig.MustProcess(context.Background(), &struct { - Port int `env:"PORT, default=8080"` - LogPath string `env:"LOG_PATH, required"` + Port int `env:"PORT, default=8080"` + FlushInterval time.Duration `env:"FLUSH_INTERVAL, default=3m"` + Bucket string `env:"BUCKET, required"` }{}) func main() { @@ -40,20 +48,79 @@ func main() { if err != nil { clog.Fatalf("failed to create event client, %v", err) } + + bucket, err := blob.OpenBucket(ctx, env.Bucket) + if err != nil { + clog.Fatalf("failed to open bucket, %v", err) + } + defer bucket.Close() + + var m sync.Mutex + writers := make(map[string]*blob.Writer, 10) + + // Periodically flush the writers to commit the data to the bucket. + go func() { + done := false + for { + writersToDrain := func() map[string]*blob.Writer { + m.Lock() + defer m.Unlock() + // Swap the writers map so we can safely iterate and close the writers. + writersToDrain := writers + writers = make(map[string]*blob.Writer, 10) + return writersToDrain + }() + + for t, w := range writersToDrain { + clog.Infof("Flushing writer[%s]", t) + if err := w.Close(); err != nil { + clog.Errorf("failed to close writer[%s]: %v", t, err) + } + } + + if done { + clog.InfoContextf(ctx, "Exiting flush loop") + return + } + select { + case <-time.After(env.FlushInterval): + case <-ctx.Done(): + clog.InfoContext(ctx, "Flushing one more time") + done = true + } + } + }() + + // Listen for events and as they come in write them to the appropriate + // writer based on event type. if err := c.StartReceiver(ctx, func(_ context.Context, event cloudevents.Event) error { - dir := filepath.Join(env.LogPath, event.Type()) - if err := os.MkdirAll(dir, 0755); err != nil { + writer, err := func() (*blob.Writer, error) { + m.Lock() + defer m.Unlock() + + w, ok := writers[event.Type()] + if !ok { + w, err = bucket.NewWriter(ctx, filepath.Join(event.Type(), strconv.FormatInt(time.Now().UnixNano(), 10)), nil) + if err != nil { + clog.Errorf("failed to create writer: %v", err) + return nil, err + } + } + writers[event.Type()] = w + return w, nil + }() + if err != nil { + clog.Errorf("failed to create writer: %v", err) return err } - filename := filepath.Join(dir, event.ID()) - if err := os.WriteFile(filename, event.Data(), 0600); err != nil { - clog.Warnf("failed to write file %s; %v", filename, err) - if err := os.RemoveAll(filename); err != nil { - clog.Warnf("failed to remove failed write file: %s; %v", filename, err) - } + // Write the event data as a line to the writer. + line := string(event.Data()) + if _, err := writer.Write([]byte(line + "\n")); err != nil { + clog.Errorf("failed to write event data: %v", err) return err } + return nil }); err != nil { clog.Fatalf("failed to start event receiver, %v", err) diff --git a/modules/cloudevent-recorder/recorder.tf b/modules/cloudevent-recorder/recorder.tf index 636eb783..0e8e8a2b 100644 --- a/modules/cloudevent-recorder/recorder.tf +++ b/modules/cloudevent-recorder/recorder.tf @@ -20,18 +20,6 @@ resource "google_storage_bucket_iam_binding" "recorder-writes-to-gcs-buckets" { members = ["serviceAccount:${google_service_account.recorder.email}"] } -locals { - lenv = [{ - name = "LOG_PATH" - value = "/logs" - }] - - logrotate_env = var.flush_interval == "" ? local.lenv : concat(local.lenv, [{ - name = "FLUSH_INTERVAL" - value = var.flush_interval - }]) -} - module "this" { count = var.method == "trigger" ? 1 : 0 source = "../regional-go-service" @@ -39,6 +27,8 @@ module "this" { name = var.name regions = var.regions + deletion_protection = var.deletion_protection + service_account = google_service_account.recorder.email containers = { "recorder" = { @@ -48,37 +38,18 @@ module "this" { } ports = [{ container_port = 8080 }] env = [{ - name = "LOG_PATH" - value = "/logs" - }] - volume_mounts = [{ - name = "logs" - mount_path = "/logs" + name = "FLUSH_INTERVAL" + value = var.flush_interval }] - resources = { - limits = var.limits - } - } - "logrotate" = { - source = { - working_dir = path.module - importpath = "./cmd/logrotate" - } - env = local.logrotate_env regional-env = [{ name = "BUCKET" value = { for k, v in google_storage_bucket.recorder : k => v.url } }] - volume_mounts = [{ - name = "logs" - mount_path = "/logs" - }] + resources = { + limits = var.limits + } } } - volumes = [{ - name = "logs" - empty_dir = {} - }] scaling = var.scaling diff --git a/modules/cloudevent-recorder/variables.tf b/modules/cloudevent-recorder/variables.tf index 16711a33..f68c36e8 100644 --- a/modules/cloudevent-recorder/variables.tf +++ b/modules/cloudevent-recorder/variables.tf @@ -141,5 +141,5 @@ variable "split_triggers" { variable "flush_interval" { description = "Flush interval for logrotate, as a duration string." type = string - default = "" + default = "3m" } diff --git a/pkg/rotate/blob.go b/pkg/rotate/blob.go deleted file mode 100644 index 11398869..00000000 --- a/pkg/rotate/blob.go +++ /dev/null @@ -1,195 +0,0 @@ -/* -Copyright 2023 Chainguard, Inc. -SPDX-License-Identifier: Apache-2.0 -*/ - -package rotate - -import ( - "bufio" - "context" - "fmt" - "io" - "io/fs" - "os" - "path/filepath" - "strconv" - "strings" - "time" - - "github.com/chainguard-dev/clog" - - "gocloud.dev/blob" - - // Add gcsblob support that we need to support gs:// prefixes - _ "gocloud.dev/blob/gcsblob" -) - -type Uploader interface { - Run(ctx context.Context) error -} - -func NewUploader(source, bucket string, flushInterval time.Duration) Uploader { - return &uploader{ - source: source, - bucket: bucket, - flushInterval: flushInterval, - } -} - -type uploader struct { - source string - bucket string - flushInterval time.Duration -} - -func (u *uploader) Run(ctx context.Context) error { - clog.InfoContextf(ctx, "Uploading combined logs from %s to %s every %g minutes", u.source, u.bucket, u.flushInterval.Minutes()) - - done := false - - for { - // This must be Background since we need to be able to upload even - // after receiving SIGTERM. - bgCtx := context.Background() - bucket, err := blob.OpenBucket(bgCtx, u.bucket) - if err != nil { - return err - } - defer bucket.Close() - - fileName := strconv.FormatInt(time.Now().UnixNano(), 10) - - fileMap := make(map[string][]string) - processed := 0 - - if err := filepath.WalkDir(u.source, func(path string, d fs.DirEntry, err error) error { - if err != nil { - return err - } - // Skip non-regular files. - if !d.Type().IsRegular() { - return nil - } - relPath, err := filepath.Rel(u.source, path) - if err != nil { - return err - } - dir, base := filepath.Split(relPath) - if _, ok := fileMap[dir]; !ok { - fileMap[dir] = []string{base} - } else { - fileMap[dir] = append(fileMap[dir], base) - } - - return nil - }); err != nil { - return err - } - for k, v := range fileMap { - clog.InfoContextf(ctx, "Found %d files in dir %s to process", len(v), k) - } - - for dir, files := range fileMap { - // Setup the GCS object with the filename to write to - writer, err := bucket.NewWriter(bgCtx, filepath.Join(dir, fileName), nil) - if err != nil { - return err - } - - var deleteErr error - for _, f := range files { - if err := u.BufferWriteToBucket(writer, filepath.Join(u.source, dir, f)); err != nil { - return fmt.Errorf("failed to upload file to blobstore: %s, %w", filepath.Join(dir, fileName), err) - } - path := filepath.Join(u.source, dir, f) - if err = os.Remove(path); err != nil { - // log the error, but continue to upload the rest of the files - clog.WarnContextf(ctx, "failed to delete file: %s %v", path, err) - deleteErr = fmt.Errorf("failed to delete file: %s %w", path, err) - } - processed++ - } - - if err := writer.Close(); err != nil { - return fmt.Errorf("failed to close blob file: %s %w", fileName, err) - } - - if deleteErr != nil { - return deleteErr - } - } - - if processed > 0 { - clog.InfoContextf(ctx, "Processed %d files to blobstore", processed) - } - if done { - clog.InfoContextf(ctx, "Exiting flush Run loop") - return nil - } - select { - case <-time.After(u.flushInterval): - case <-ctx.Done(): - clog.InfoContext(ctx, "Flushing one more time") - done = true - } - } -} - -func Upload(ctx context.Context, fr io.Reader, bucket, fileName string) error { - b, err := blob.OpenBucket(ctx, bucket) - if err != nil { - return err - } - defer b.Close() - // Setup the blob with the filename to write to - writer, err := b.NewWriter(ctx, fileName, nil) - if err != nil { - return err - } - n, err := writer.ReadFrom(fr) - if err != nil { - return err - } - fmt.Printf("Wrote %d bytes\n", n) - if err := writer.Close(); err != nil { - return fmt.Errorf("failed to close blob file %w", err) - } - return nil -} - -func (u *uploader) BufferWriteToBucket(writer *blob.Writer, src string) (err error) { - f, err := os.Open(src) - if err != nil { - return err - } - - defer func() { - ferr := f.Close() - if ferr != nil { - err = fmt.Errorf("failed to close source file: %s %w", src, err) - } - }() - - s := bufio.NewScanner(f) - // Increase the buffer size. Here we set it to 5MB, this is because the default buffer size is 64KB and some - // log files that come from broker events can contain very long lines. - buf := make([]byte, 0, 1024*1024*5) // Initial size of 0, max size of 5MB - s.Buffer(buf, cap(buf)) - - for s.Scan() { - line := strings.TrimSpace(s.Text()) - if len(line) == 0 { - continue - } - if _, err := writer.Write([]byte(line + "\n")); err != nil { - return err - } - } - if s.Err() != nil { - // log the error and use alerting to investigates errors - clog.Errorf("bufio scan error: %v", s.Err()) - } - - return nil -} diff --git a/pkg/rotate/blob_test.go b/pkg/rotate/blob_test.go deleted file mode 100644 index 0c0561e5..00000000 --- a/pkg/rotate/blob_test.go +++ /dev/null @@ -1,242 +0,0 @@ -/* -Copyright 2023 Chainguard, Inc. -SPDX-License-Identifier: Apache-2.0 -*/ - -package rotate - -import ( - "bytes" - "context" - "errors" - "fmt" - "io" - "os" - "path/filepath" - "testing" - "time" - - "gocloud.dev/blob/memblob" - - "github.com/google/go-cmp/cmp" - "github.com/google/go-cmp/cmp/cmpopts" - "gocloud.dev/blob" - _ "gocloud.dev/blob/fileblob" - "golang.org/x/exp/maps" -) - -var ( - wantBeforeBlobs = map[string]string{ - "unit/test/0": "UNIT TEST: 0\n", - "unit-test-1": "UNIT TEST: 1\n", - "unit/test/2": "UNIT TEST: 2\n", - "unit-test-3": "UNIT TEST: 3\n", - "unit/test/4": "UNIT TEST: 4\n", - } - - wantBeforeCombineBlobs = []string{ - "UNIT TEST: 1\nUNIT TEST: 3\n", - "UNIT TEST: 0\nUNIT TEST: 2\nUNIT TEST: 4\n", - } - - wantAfterCombineBlobs = []string{ - "LAST UT\n", - "UNIT TEST: 1\nUNIT TEST: 3\n", - "UNIT TEST: 0\nUNIT TEST: 2\nUNIT TEST: 4\n", - } -) - -func TestBlobUploader(t *testing.T) { - dir := t.TempDir() - blobDir := t.TempDir() - - cancelCtx, cancel := context.WithCancel(context.Background()) - bucketName := "file://" + blobDir - bucket, err := blob.OpenBucket(cancelCtx, bucketName) - if err != nil { - t.Fatalf("Failed to create a bucket: %v", err) - } - defer os.RemoveAll(dir) // clean up - - uploader := NewUploader(dir, bucketName, 1*time.Minute) - - // Create a few files there to be uploaded - for i := 0; i < 5; i++ { - var filename string - if i%2 == 0 { - filename = fmt.Sprintf("%s/unit/test/%d", dir, i) - } else { - filename = fmt.Sprintf("%s/unit-test-%d", dir, i) - } - if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { - t.Errorf("MkdirAll() = %v", err) - } - contents := fmt.Sprintf("UNIT TEST: %d", i) - err := os.WriteFile(filename, []byte(contents), 0600) - if err != nil { - t.Errorf("Failed to write file %d: %v\n", i, err) - } - } - for i, b := range []string{"", "\n"} { - x := i + 5 - var filename string - if i%2 == 0 { - filename = fmt.Sprintf("%s/unit/test/%d", dir, x) - } else { - filename = fmt.Sprintf("%s/unit-test-%d", dir, x) - } - err := os.WriteFile(filename, []byte(b), 0600) - if err != nil { - t.Errorf("Failed to write file %d: %v\n", x, err) - } - } - - // Start the uploader - go uploader.Run(cancelCtx) - - // Give a little time for uploads, then make sure we have all the files - // there. - time.Sleep(3 * time.Second) - blobsBefore, err := getFiles(cancelCtx, bucket) - if err != nil { - t.Errorf("Failed to read files from blobstore: %v", err) - } - less := func(a, b string) bool { return a < b } - if !cmp.Equal(maps.Values(blobsBefore), wantBeforeCombineBlobs, cmpopts.SortSlices(less)) { - t.Errorf("Did not get expected blobs '%s'\n%v\n%v", cmp.Diff(wantBeforeCombineBlobs, maps.Values(blobsBefore), cmpopts.SortSlices(less)), wantBeforeCombineBlobs, maps.Values(blobsBefore)) - } - - // Then write one more file and trigger cancel, so this too should be now - // written there. - filename := fmt.Sprintf("%s/last", dir) - err = os.WriteFile(filename, []byte("LAST UT"), 0600) - if err != nil { - t.Errorf("Failed to write: %v", err) - } - - // Now one more check, make sure that the file does not get - // immediately uploaded. So check that the files have not been - // uploaded. Then trigger shutdown and ensure the file then gets uploaded - // as 'not per schedule', but aggressive flush during shutdown. - blobsAfter, err := getFiles(cancelCtx, bucket) - if err != nil { - t.Errorf("Failed to read files from blobstore: %v", err) - } - if !cmp.Equal(maps.Values(blobsAfter), wantBeforeCombineBlobs, cmpopts.SortSlices(less)) { - t.Errorf("Did not get expected blobs '%s'\n%v\n%v", cmp.Diff(wantBeforeCombineBlobs, maps.Values(blobsAfter), cmpopts.SortSlices(less)), wantBeforeCombineBlobs, maps.Values(blobsAfter)) - } - - cancel() - time.Sleep(3 * time.Second) - blobsAfter, err = getFiles(cancelCtx, bucket) - if err != nil { - t.Errorf("Failed to read files from blobstore: %v", err) - } - if !cmp.Equal(maps.Values(blobsAfter), wantAfterCombineBlobs, cmpopts.SortSlices(less)) { - t.Errorf("Did not get expected blobs '%s'\n%v\n%v", cmp.Diff(wantAfterCombineBlobs, maps.Values(blobsAfter), cmpopts.SortSlices(less)), wantAfterCombineBlobs, maps.Values(blobsAfter)) - } -} - -func TestBlobUploaderNoop(t *testing.T) { - dir := t.TempDir() - defer os.RemoveAll(dir) // clean up - blobDir := t.TempDir() - - bucketName := "file://" + blobDir - - uploader := NewUploader(dir, bucketName, 1*time.Minute) - - ctx, cancel := context.WithTimeout(context.Background(), time.Millisecond*80) - defer cancel() - uploader.Run(ctx) -} - -func TestBlobUpload(t *testing.T) { - blobDir := t.TempDir() - - ctx := context.Background() - bucketName := "file://" + blobDir - bucket, err := blob.OpenBucket(ctx, bucketName) - if err != nil { - t.Fatalf("Failed to create a bucket: %v", err) - } - - // Upload the files - for i := 0; i < 5; i++ { - var filename string - if i%2 == 0 { - filename = fmt.Sprintf("unit/test/%d", i) - } else { - filename = fmt.Sprintf("unit-test-%d", i) - } - contents := fmt.Sprintf("UNIT TEST: %d\n", i) - buf := bytes.NewBuffer([]byte(contents)) - if err := Upload(ctx, buf, bucketName, filename); err != nil { - t.Errorf("Failed to upload file %d: %v\n", i, err) - } - } - - blobsBefore, err := getFiles(ctx, bucket) - if err != nil { - t.Errorf("Failed to read files from blobstore: %v", err) - } - if !cmp.Equal(blobsBefore, wantBeforeBlobs) { - t.Errorf("Did not get expected blobs %s", cmp.Diff(wantBeforeBlobs, blobsBefore)) - } -} - -func getFiles(ctx context.Context, bucket *blob.Bucket) (map[string]string, error) { - blobs := map[string]string{} - iter := bucket.List(nil) - for { - obj, err := iter.Next(ctx) - if errors.Is(err, io.EOF) { - break - } - if err != nil { - return blobs, err - } - data, err := bucket.ReadAll(ctx, obj.Key) - if err != nil { - return blobs, err - } - blobs[obj.Key] = string(data) - } - return blobs, nil -} - -func TestBufferWriteToBucket(t *testing.T) { - ctx := context.Background() - testFilename := filepath.Join("testdata", "long_event_line.json") - longEventLine, err := os.ReadFile(testFilename) - if err != nil { - t.Fatalf("Failed to read long_event_line.json: %v", err) - } - u := &uploader{} - - bucket := memblob.OpenBucket(nil) - defer bucket.Close() - - dstKey := "testkey-dst" - writer, err := bucket.NewWriter(ctx, "testkey-dst", nil) - - if err != nil { - t.Fatalf("failed to create writer: %v", err) - } - - err = u.BufferWriteToBucket(writer, testFilename) - if err != nil { - t.Fatalf("failed to upload file to blobstore: %v", err) - } - - if err := writer.Close(); err != nil { - t.Fatal(err) - } - got, err := bucket.ReadAll(ctx, dstKey) - if err != nil { - t.Fatal(err) - } - if !cmp.Equal(got, longEventLine) { - t.Errorf("got %v, want %v", got, longEventLine) - } -} diff --git a/pkg/rotate/testdata/long_event_line.json b/pkg/rotate/testdata/long_event_line.json deleted file mode 100644 index 4a82d1cd..00000000 --- a/pkg/rotate/testdata/long_event_line.json +++ /dev/null @@ -1,2 +0,0 @@ -{"time":"2024-04-02T20:20:51.657533242Z","severity":"INFO","message":"Uploading line: {\"ID\":\"fa123894d6511f6eb07d6b6bb1b3e247150a8173c73c0e39cfe71117f95b62c1\",\"image\":\"cgr.dev/chainguard/opensearch:latest\",\"digest\":\"sha256:170ea5ada8df59fcc9c5a89c8cbe50574ef6ae5bbbc6984aea6c5bcde771b0da\",\"scanner\":\"grype\",\"scanner_version\":\"0.74.7\",\"scanner_db_version\":\"sha256:1711e28fa8e54e48cf01aac5cb051bffe2bb19486664e9b65d05358795bf4ff8\",\"time\":\"2024-04-02T20:09:43Z\",\"created\":\"2024-03-28T19:18:01Z\",\"low_cve_count\":0,\"med_cve_count\":6,\"high_cve_count\":0,\"crit_cve_count\":0,\"negligible_cve_count\":0,\"unknown_cve_count\":0,\"tot_cve_count\":6,\"success\":true,\"raw_grype_json\":\"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\",\"raw_syft_json\":\"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" -}