From 21d81564027b0953b7c239329d944ae9e1b4d2c0 Mon Sep 17 00:00:00 2001 From: Valentin Daviot Date: Thu, 21 May 2026 14:00:18 +0200 Subject: [PATCH 1/3] chore: migrate from zerolog to log/slog Replace `github.com/rs/zerolog` with the standard library `log/slog` in the integration test binaries (`tests/integration/`). The importable `pkg/` library code has no logging and is unaffected. - Drop direct dependency on `github.com/rs/zerolog` (still pulled in transitively by the `mockery` dev tool under the `tools` build tag, so it remains as `// indirect` in go.mod after `go mod tidy`). - Use `slog.NewJSONHandler` for JSON output, matching prior format. - Convert all log call-sites to typed `slog.Attr` helpers (`slog.String`, `slog.Any`, ...) and the `*Context` methods, threading a `context.Context` through the tester methods. - Rename the implicit zerolog `error` field to `error_message` to align with the logger-field-naming convention. - Map zerolog `Fatal()` to `ErrorContext(...)` + `os.Exit(1)` since `log/slog` does not provide a Fatal level. Note on public API: the `*zerolog.Logger` parameters that change to `*slog.Logger` (`NewSoftwareRAIDControllerTester`, and `runSoftwareControllerIntegrationTestSuite`) are in `package main` inside `tests/integration/`, so they are not importable by external consumers. There is no breaking change to `github.com/scality/raidmgmt`'s public API surface for downstream callers such as `platform-raid-report-generator`. Co-authored-by: Cursor --- go.mod | 2 +- tests/integration/main.go | 12 +- tests/integration/software_raid_controller.go | 147 +++++++++--------- 3 files changed, 84 insertions(+), 77 deletions(-) diff --git a/go.mod b/go.mod index 4c38e75..40c47e9 100644 --- a/go.mod +++ b/go.mod @@ -4,7 +4,6 @@ go 1.25.6 require ( github.com/pkg/errors v0.9.1 - github.com/rs/zerolog v1.34.0 github.com/stretchr/testify v1.11.1 github.com/vektra/mockery/v2 v2.53.6 ) @@ -25,6 +24,7 @@ require ( github.com/pelletier/go-toml/v2 v2.2.4 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rogpeppe/go-internal v1.14.1 // indirect + github.com/rs/zerolog v1.34.0 // indirect github.com/sagikazarmark/locafero v0.12.0 // indirect github.com/spf13/afero v1.15.0 // indirect github.com/spf13/cast v1.10.0 // indirect diff --git a/tests/integration/main.go b/tests/integration/main.go index e61404c..32e6982 100644 --- a/tests/integration/main.go +++ b/tests/integration/main.go @@ -1,10 +1,10 @@ package main import ( + "context" + "log/slog" "os" - "github.com/rs/zerolog" - "github.com/scality/raidmgmt/pkg/core" "github.com/scality/raidmgmt/pkg/implementation/commandrunner" "github.com/scality/raidmgmt/pkg/implementation/logicalvolumegetter" @@ -15,7 +15,9 @@ import ( // Remove the full array. func main() { - logger := zerolog.New(os.Stdout).With().Str("test_type", "integration").Logger() + ctx := context.Background() + logger := slog.New(slog.NewJSONHandler(os.Stdout, nil)). + With(slog.String("test_type", "integration")) uDevADMCommandRunner := commandrunner.NewUDevADM(nil) lsblkCommandRunner := commandrunner.NewLSBLK(nil) @@ -46,7 +48,7 @@ func main() { ), ) - tester := NewSoftwareRAIDControllerTester(*controller, &logger) + tester := NewSoftwareRAIDControllerTester(*controller, logger) - tester.runSoftwareControllerIntegrationTestSuite(&logger) + tester.runSoftwareControllerIntegrationTestSuite(ctx, logger) } diff --git a/tests/integration/software_raid_controller.go b/tests/integration/software_raid_controller.go index c73953b..6072a49 100644 --- a/tests/integration/software_raid_controller.go +++ b/tests/integration/software_raid_controller.go @@ -2,10 +2,12 @@ package main import ( + "context" "fmt" + "log/slog" + "os" "github.com/pkg/errors" - "github.com/rs/zerolog" "github.com/scality/raidmgmt/pkg/core" "github.com/scality/raidmgmt/pkg/domain/entities/logicalvolume" @@ -15,12 +17,12 @@ import ( type SoftwareRAIDControllerTester struct { controller core.RAIDController - logger *zerolog.Logger + logger *slog.Logger } func NewSoftwareRAIDControllerTester( controller core.RAIDController, - logger *zerolog.Logger, + logger *slog.Logger, ) *SoftwareRAIDControllerTester { return &SoftwareRAIDControllerTester{ controller: controller, @@ -28,18 +30,18 @@ func NewSoftwareRAIDControllerTester( } } -func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { - l := t.logger.With().Str("test_case", "raid10").Logger() +func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error { + l := t.logger.With(slog.String("test_case", "raid10")) physicalDrives, err := t.controller.PhysicalDrives(&raidcontroller.Metadata{}) if err != nil { - l.Error().Err(err).Msg("failed to get physical drives") + l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get physical drives") } if len(physicalDrives) < 4 { - l.Error().Msg("not enough physical drives") + l.ErrorContext(ctx, "not enough physical drives") return errors.New("not enough physical drives to run test case") } @@ -74,22 +76,22 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { // Create RAID1 with 4 disks logicalVolume, err := t.controller.CreateLV(creationRequest) if err != nil { - l.Error().Err(err).Msg("failed to create RAID1") + l.ErrorContext(ctx, "failed to create RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to create RAID1") } - l.Info().Msg("Created RAID10 Logical volume") + l.InfoContext(ctx, "Created RAID10 Logical volume") defer func() { // Remove the full array err = t.controller.DeleteLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to delete RAID10") + l.ErrorContext(ctx, "failed to delete RAID10", slog.Any("error_message", err)) return } - l.Info().Msg("RAID10 array deleted") + l.InfoContext(ctx, "RAID10 array deleted") }() drives := []*physicaldrive.Metadata{ @@ -101,51 +103,51 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.Error().Err(err).Msg("RAID1 should not be able to remove a disk if only two are there") + l.ErrorContext(ctx, "RAID1 should not be able to remove a disk if only two are there", slog.Any("error_message", err)) return errors.Wrap(err, "RAID1 should not be able to remove a disk if only two are there") } - l.Info().Msg("RAID10 removed a disk, array is degraded") + l.InfoContext(ctx, "RAID10 removed a disk, array is degraded") logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to get logical volume") + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get logical volume") } if len(logicalVolume.PDrivesMetadata) != 3 { - l.Error().Msg("RAID10 should have 3 disks now") + l.ErrorContext(ctx, "RAID10 should have 3 disks now") return errors.New("RAID10 should have 3 disks now") } - l.Info().Msg("RAID10 has 3 disks now") + l.InfoContext(ctx, "RAID10 has 3 disks now") - l.Info().Msg("Adding 1 disk") + l.InfoContext(ctx, "Adding 1 disk") err = t.controller.AddPDsToLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.Error().Err(err).Msg("failed to extend RAID1") + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to extend RAID1") } logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to get logical volume") + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get logical volume") } if len(logicalVolume.PDrivesMetadata) != 4 { - l.Error().Msg("RAID10 should have 4 disks now") + l.ErrorContext(ctx, "RAID10 should have 4 disks now") return errors.New("RAID10 should have 4 disks now") } - l.Info().Msg("RAID10 has 4 disks now") + l.InfoContext(ctx, "RAID10 has 4 disks now") drives = []*physicaldrive.Metadata{ { @@ -158,53 +160,53 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { }, } - l.Info().Msg("Removing 2 disks") + l.InfoContext(ctx, "Removing 2 disks") err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.Error().Err(err).Msg("failed to extend RAID1") + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to extend RAID1") } logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to get logical volume") + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get logical volume") } if len(logicalVolume.PDrivesMetadata) != 2 { - l.Error().Msg("RAID10 should have 2 disks now") + l.ErrorContext(ctx, "RAID10 should have 2 disks now") return errors.New("RAID10 should have 2 disks now") } - l.Info().Msg("RAID10 has 2 disks now") + l.InfoContext(ctx, "RAID10 has 2 disks now") - l.Info().Msg("Adding 2 disks") + l.InfoContext(ctx, "Adding 2 disks") err = t.controller.AddPDsToLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.Error().Err(err).Msg("failed to extend RAID1") + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to extend RAID1") } logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to get logical volume") + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get logical volume") } if len(logicalVolume.PDrivesMetadata) != 4 { - l.Error().Msg("RAID10 should have 4 disks now") + l.ErrorContext(ctx, "RAID10 should have 4 disks now") return errors.New("RAID10 should have 4 disks now") } - l.Info().Msg("RAID10 has 4 disks now") + l.InfoContext(ctx, "RAID10 has 4 disks now") drives = []*physicaldrive.Metadata{ { @@ -217,16 +219,16 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { }, } - l.Info().Msg("Removing 2 disks from the same array, should fail") + l.InfoContext(ctx, "Removing 2 disks from the same array, should fail") err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err == nil { - l.Error().Msg("Didn't fail to remove 2 disks from the same array") + l.ErrorContext(ctx, "Didn't fail to remove 2 disks from the same array") return errors.Wrap(err, "Didn't fail to remove 2 disks from the same array") } - l.Info().Msg("RAID10 failed to remove 2 disks from the same array as expected") + l.InfoContext(ctx, "RAID10 failed to remove 2 disks from the same array as expected") drives = []*physicaldrive.Metadata{ { @@ -241,63 +243,66 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests() error { err = t.controller.AddPDsToLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.Error().Err(err).Msg("failed to extend RAID1") + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to extend RAID1") } - l.Info().Msg("Added 2 more disks to RAID10 array") + l.InfoContext(ctx, "Added 2 more disks to RAID10 array") logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to get logical volume") + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get logical volume") } fmt.Println(logicalVolume.Size) - l.Info().Msg("RAID10 tests passed") + l.InfoContext(ctx, "RAID10 tests passed") return nil } -func (t *SoftwareRAIDControllerTester) runSoftwareControllerIntegrationTestSuite(logger *zerolog.Logger) { - l := logger.With().Str("test_suite", "software_raid_controller").Logger() +func (t *SoftwareRAIDControllerTester) runSoftwareControllerIntegrationTestSuite(ctx context.Context, logger *slog.Logger) { + l := logger.With(slog.String("test_suite", "software_raid_controller")) - err := t.runRAID0Tests() + err := t.runRAID0Tests(ctx) if err != nil { - l.Fatal().Err(err).Msg("failed to run RAID0 tests") + l.ErrorContext(ctx, "failed to run RAID0 tests", slog.Any("error_message", err)) + os.Exit(1) } - l.Info().Msg("RAID0 tests passed") + l.InfoContext(ctx, "RAID0 tests passed") - err = t.runRAID1Tests() + err = t.runRAID1Tests(ctx) if err != nil { - l.Fatal().Err(err).Msg("failed to run RAID1 tests") + l.ErrorContext(ctx, "failed to run RAID1 tests", slog.Any("error_message", err)) + os.Exit(1) } - l.Info().Msg("RAID1 tests passed") + l.InfoContext(ctx, "RAID1 tests passed") - err = t.runRAID10Tests() + err = t.runRAID10Tests(ctx) if err != nil { - l.Fatal().Err(err).Msg("failed to run RAID10 tests") + l.ErrorContext(ctx, "failed to run RAID10 tests", slog.Any("error_message", err)) + os.Exit(1) } } // Remove the full array. -func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { - l := t.logger.With().Str("test_case", "raid1").Logger() +func (t *SoftwareRAIDControllerTester) runRAID1Tests(ctx context.Context) error { + l := t.logger.With(slog.String("test_case", "raid1")) physicalDrives, err := t.controller.PhysicalDrives(&raidcontroller.Metadata{}) if err != nil { - l.Error().Err(err).Msg("failed to get physical drives") + l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get physical drives") } if len(physicalDrives) < 3 { - l.Error().Msg("not enough physical drives") + l.ErrorContext(ctx, "not enough physical drives") return errors.New("not enough physical drives to run test case") } @@ -324,7 +329,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { // Create RAID1 with 2 disks logicalVolume, err := t.controller.CreateLV(creationRequest) if err != nil { - l.Error().Err(err).Msg("failed to create RAID1") + l.ErrorContext(ctx, "failed to create RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to create RAID1") } @@ -333,11 +338,11 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { // Remove the full array err = t.controller.DeleteLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to delete RAID1") + l.ErrorContext(ctx, "failed to delete RAID1", slog.Any("error_message", err)) return } - l.Info().Msg("RAID1 array deleted") + l.InfoContext(ctx, "RAID1 array deleted") }() drives := []*physicaldrive.Metadata{ @@ -349,7 +354,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err == nil { - l.Error().Err(err).Msg("RAID1 should not be able to remove a disk if only two are there") + l.ErrorContext(ctx, "RAID1 should not be able to remove a disk if only two are there", slog.Any("error_message", err)) return errors.Wrap(err, "RAID1 should not be able to remove a disk if only two are there") } @@ -368,7 +373,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { drives..., ) if err != nil { - l.Error().Err(err).Msg("failed to extend RAID1") + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) return errors.Wrap(err, "failed to extend RAID1") } @@ -376,18 +381,18 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests() error { return nil } -func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { - l := t.logger.With().Str("test_case", "raid0").Logger() +func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error { + l := t.logger.With(slog.String("test_case", "raid0")) physicalDrives, err := t.controller.PhysicalDrives(&raidcontroller.Metadata{}) if err != nil { - l.Error().Err(err).Msg("failed to get physical drives") + l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get physical drives") } if len(physicalDrives) < 3 { - l.Error().Msg("not enough physical drives") + l.ErrorContext(ctx, "not enough physical drives") return errors.New("not enough physical drives to run test case") } @@ -416,12 +421,12 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { // Create with 2 disks logicalVolume, err := t.controller.CreateLV(creationRequest) if err != nil { - l.Error().Err(err).Msg("failed to create RAID0") + l.ErrorContext(ctx, "failed to create RAID0", slog.Any("error_message", err)) return errors.Wrap(err, "failed to create RAID0") } - l.Info().Str("device_path", logicalVolume.DevicePath).Msg("RAID0 created") + l.InfoContext(ctx, "RAID0 created", slog.String("device_path", logicalVolume.DevicePath)) // Extend with one extra disk => make sure the array size is equal of sum of disk sizes @@ -437,12 +442,12 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { drives..., ) if err != nil { - l.Error().Err(err).Msg("failed to extend RAID0") + l.ErrorContext(ctx, "failed to extend RAID0", slog.Any("error_message", err)) return errors.Wrap(err, "failed to extend RAID0") } - l.Info().Msg("RAID0 extended") + l.InfoContext(ctx, "RAID0 extended") // previousSize := logicalVolume.Size @@ -452,7 +457,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { CtrlMetadata: controllerMetadata, }) if err != nil { - l.Error().Err(err).Msg("failed to get logical volume") + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -468,26 +473,26 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests() error { // FIXME The size part is not working as expected for now // But i can confirm that the size is equal to the sum of the disks - l.Info().Msg("RAID0 size is equal to sum of disk sizes") + l.InfoContext(ctx, "RAID0 size is equal to sum of disk sizes") err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err == nil { - l.Error().Msg("RAID0 should not be able to remove a disk") + l.ErrorContext(ctx, "RAID0 should not be able to remove a disk") return errors.New("RAID0 should not be able to remove a disk") } - l.Info().Msg("RAID0 cannot remove a disk") + l.InfoContext(ctx, "RAID0 cannot remove a disk") // Remove the full array err = t.controller.DeleteLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.Error().Err(err).Msg("failed to delete RAID0") + l.ErrorContext(ctx, "failed to delete RAID0", slog.Any("error_message", err)) return errors.Wrap(err, "failed to delete RAID0") } - l.Info().Msg("RAID0 array deleted") + l.InfoContext(ctx, "RAID0 array deleted") return nil } From 2ef4da127f735541a33bc7ab23694d8a7f2a7b47 Mon Sep 17 00:00:00 2001 From: Valentin Daviot Date: Thu, 21 May 2026 14:04:18 +0200 Subject: [PATCH 2/3] chore: update commented-out zerolog example to slog form Align the dead commented-out logging call with the rest of the migrated file (uses `InfoContext(ctx, ...)` instead of zerolog's fluent `.Info().Msg(...)`). Behavior unchanged. Co-authored-by: Cursor --- tests/integration/software_raid_controller.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/integration/software_raid_controller.go b/tests/integration/software_raid_controller.go index 6072a49..d3b9ec0 100644 --- a/tests/integration/software_raid_controller.go +++ b/tests/integration/software_raid_controller.go @@ -466,7 +466,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error // break // } // - // l.Info().Msg("Waiting for RAID0 size to be updated") + // l.InfoContext(ctx, "Waiting for RAID0 size to be updated") // time.Sleep(5 * time.Second) // } From 6b5573298e8d1b3d8d0ab71f5e0b18919cd6dad2 Mon Sep 17 00:00:00 2001 From: Valentin Daviot Date: Thu, 21 May 2026 15:17:45 +0200 Subject: [PATCH 3/3] chore: rename slog field key error_message to error Use the shorter `error` key for the wrapped error attribute on `*Context` log calls, matching the convention adopted PR-wide. Co-authored-by: Cursor --- tests/integration/software_raid_controller.go | 52 +++++++++---------- 1 file changed, 26 insertions(+), 26 deletions(-) diff --git a/tests/integration/software_raid_controller.go b/tests/integration/software_raid_controller.go index d3b9ec0..195a791 100644 --- a/tests/integration/software_raid_controller.go +++ b/tests/integration/software_raid_controller.go @@ -35,7 +35,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error physicalDrives, err := t.controller.PhysicalDrives(&raidcontroller.Metadata{}) if err != nil { - l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error", err)) return errors.Wrap(err, "failed to get physical drives") } @@ -76,7 +76,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error // Create RAID1 with 4 disks logicalVolume, err := t.controller.CreateLV(creationRequest) if err != nil { - l.ErrorContext(ctx, "failed to create RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to create RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to create RAID1") } @@ -87,7 +87,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error // Remove the full array err = t.controller.DeleteLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to delete RAID10", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to delete RAID10", slog.Any("error", err)) return } @@ -103,7 +103,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.ErrorContext(ctx, "RAID1 should not be able to remove a disk if only two are there", slog.Any("error_message", err)) + l.ErrorContext(ctx, "RAID1 should not be able to remove a disk if only two are there", slog.Any("error", err)) return errors.Wrap(err, "RAID1 should not be able to remove a disk if only two are there") } @@ -112,7 +112,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -129,14 +129,14 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error err = t.controller.AddPDsToLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to extend RAID1") } logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -164,14 +164,14 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to extend RAID1") } logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -188,14 +188,14 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error err = t.controller.AddPDsToLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to extend RAID1") } logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -243,7 +243,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error err = t.controller.AddPDsToLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err != nil { - l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to extend RAID1") } @@ -252,7 +252,7 @@ func (t *SoftwareRAIDControllerTester) runRAID10Tests(ctx context.Context) error logicalVolume, err = t.controller.LogicalVolume(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -269,7 +269,7 @@ func (t *SoftwareRAIDControllerTester) runSoftwareControllerIntegrationTestSuite err := t.runRAID0Tests(ctx) if err != nil { - l.ErrorContext(ctx, "failed to run RAID0 tests", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to run RAID0 tests", slog.Any("error", err)) os.Exit(1) } @@ -277,7 +277,7 @@ func (t *SoftwareRAIDControllerTester) runSoftwareControllerIntegrationTestSuite err = t.runRAID1Tests(ctx) if err != nil { - l.ErrorContext(ctx, "failed to run RAID1 tests", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to run RAID1 tests", slog.Any("error", err)) os.Exit(1) } @@ -285,7 +285,7 @@ func (t *SoftwareRAIDControllerTester) runSoftwareControllerIntegrationTestSuite err = t.runRAID10Tests(ctx) if err != nil { - l.ErrorContext(ctx, "failed to run RAID10 tests", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to run RAID10 tests", slog.Any("error", err)) os.Exit(1) } } @@ -296,7 +296,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests(ctx context.Context) error physicalDrives, err := t.controller.PhysicalDrives(&raidcontroller.Metadata{}) if err != nil { - l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error", err)) return errors.Wrap(err, "failed to get physical drives") } @@ -329,7 +329,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests(ctx context.Context) error // Create RAID1 with 2 disks logicalVolume, err := t.controller.CreateLV(creationRequest) if err != nil { - l.ErrorContext(ctx, "failed to create RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to create RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to create RAID1") } @@ -338,7 +338,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests(ctx context.Context) error // Remove the full array err = t.controller.DeleteLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to delete RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to delete RAID1", slog.Any("error", err)) return } @@ -354,7 +354,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests(ctx context.Context) error err = t.controller.DeletePDsFromLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}, drives...) if err == nil { - l.ErrorContext(ctx, "RAID1 should not be able to remove a disk if only two are there", slog.Any("error_message", err)) + l.ErrorContext(ctx, "RAID1 should not be able to remove a disk if only two are there", slog.Any("error", err)) return errors.Wrap(err, "RAID1 should not be able to remove a disk if only two are there") } @@ -373,7 +373,7 @@ func (t *SoftwareRAIDControllerTester) runRAID1Tests(ctx context.Context) error drives..., ) if err != nil { - l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to extend RAID1", slog.Any("error", err)) return errors.Wrap(err, "failed to extend RAID1") } @@ -386,7 +386,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error physicalDrives, err := t.controller.PhysicalDrives(&raidcontroller.Metadata{}) if err != nil { - l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get physical drives", slog.Any("error", err)) return errors.Wrap(err, "failed to get physical drives") } @@ -421,7 +421,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error // Create with 2 disks logicalVolume, err := t.controller.CreateLV(creationRequest) if err != nil { - l.ErrorContext(ctx, "failed to create RAID0", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to create RAID0", slog.Any("error", err)) return errors.Wrap(err, "failed to create RAID0") } @@ -442,7 +442,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error drives..., ) if err != nil { - l.ErrorContext(ctx, "failed to extend RAID0", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to extend RAID0", slog.Any("error", err)) return errors.Wrap(err, "failed to extend RAID0") } @@ -457,7 +457,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error CtrlMetadata: controllerMetadata, }) if err != nil { - l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to get logical volume", slog.Any("error", err)) return errors.Wrap(err, "failed to get logical volume") } @@ -487,7 +487,7 @@ func (t *SoftwareRAIDControllerTester) runRAID0Tests(ctx context.Context) error // Remove the full array err = t.controller.DeleteLV(&logicalvolume.Metadata{ID: logicalVolume.DevicePath, CtrlMetadata: controllerMetadata}) if err != nil { - l.ErrorContext(ctx, "failed to delete RAID0", slog.Any("error_message", err)) + l.ErrorContext(ctx, "failed to delete RAID0", slog.Any("error", err)) return errors.Wrap(err, "failed to delete RAID0") }