Merge branch 'main' into renovate/github.com-cloudquery-plugin-pb-go-1.x

kodiakhq[bot] · web-flow · commit cf1c6c7c6eee · 2025-03-05T12:39:09.000Z
diff --git a/.github/workflows/lint_golang.yml b/.github/workflows/lint_golang.yml
@@ -20,4 +20,4 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v6
         with:
-          version: v1.63.4
+          version: v1.64.5
diff --git a/.golangci.yml b/.golangci.yml
@@ -86,3 +86,6 @@ linters:
     - unconvert
     - unparam
     - unused
+issues:
+  max-issues-per-linter: 0
+  max-same-issues: 0
diff --git a/configtype/time.go b/configtype/time.go
@@ -2,6 +2,7 @@ package configtype
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math"
 	"regexp"
@@ -212,13 +213,13 @@ func parseTimeDuration(s string) (timeDuration, error) {
 			inValue = false
 		case part == "ago":
 			if d.sign != 0 {
-				return timeDuration{}, fmt.Errorf("invalid duration format: more than one sign specifier")
+				return timeDuration{}, errors.New("invalid duration format: more than one sign specifier")
 			}
 
 			d.sign = -1
 		case part == "from":
 			if d.sign != 0 {
-				return timeDuration{}, fmt.Errorf("invalid duration format: more than one sign specifier")
+				return timeDuration{}, errors.New("invalid duration format: more than one sign specifier")
 			}
 
 			inSign = true
diff --git a/faker/faker.go b/faker/faker.go
@@ -2,6 +2,7 @@ package faker
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"math/rand"
 	"reflect"
@@ -15,16 +16,16 @@ type faker struct {
 	logger   zerolog.Logger
 }
 
-var errEFaceNotAllowed = fmt.Errorf("any not allowed")
+var errEFaceNotAllowed = errors.New("any not allowed")
 
-func (f faker) getFakedValue(a any) (reflect.Value, error) {
+func (f *faker) getFakedValue(a any) (reflect.Value, error) {
 	t := reflect.TypeOf(a)
 	if t == nil {
 		return reflect.Value{}, errEFaceNotAllowed
 	}
 	f.maxDepth--
 	if f.maxDepth < 0 {
-		return reflect.Value{}, fmt.Errorf("max_depth reached")
+		return reflect.Value{}, errors.New("max_depth reached")
 	}
 	k := t.Kind()
 	switch k {
@@ -176,7 +177,7 @@ func FakeObject(obj any, opts ...Option) error {
 	reflectType := reflect.TypeOf(obj)
 
 	if reflectType.Kind() != reflect.Ptr {
-		return fmt.Errorf("object is not a pointer")
+		return errors.New("object is not a pointer")
 	}
 
 	if reflect.ValueOf(obj).IsNil() {
diff --git a/faker/faker_test.go b/faker/faker_test.go
@@ -6,7 +6,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type testFakerStruct struct {
@@ -97,3 +99,63 @@ func TestFakerCanFakeNetIP(t *testing.T) {
 	assert.NotEmpty(t, a.NestedComplex.IPAddress)
 	assert.Equal(t, "1.1.1.1", a.NestedComplex.IPAddress.String())
 }
+
+func TestMaxDepth(t *testing.T) {
+	// Struct with nested structs
+	a := struct {
+		A struct {
+			A struct {
+				A struct {
+					A struct {
+						A struct {
+							A struct {
+								A struct {
+									A struct {
+										A struct {
+											A struct {
+												A struct {
+													A struct {
+														A struct {
+															A struct {
+																A struct {
+																	A struct {
+																		A struct {
+																			A string
+																		}
+																	}
+																}
+															}
+														}
+													}
+												}
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}{}
+
+	sink := &testLogSink{}
+	testLogger := zerolog.New(sink)
+	require.NoError(t, FakeObject(&a, WithLogger(testLogger)), "max depth reached")
+	require.Equal(t, 1, len(sink.getLogs()))
+	require.Contains(t, sink.getLogs()[0], "max_depth reached")
+}
+
+type testLogSink struct {
+	logs []string
+}
+
+func (sink *testLogSink) Write(p []byte) (n int, err error) {
+	sink.logs = append(sink.logs, string(p))
+	return len(p), nil
+}
+
+func (sink *testLogSink) getLogs() []string {
+	return sink.logs
+}
diff --git a/helpers/remoteoauth/token.go b/helpers/remoteoauth/token.go
@@ -114,7 +114,7 @@ func (t *cloudTokenSource) retrieveToken(ctx context.Context) (*oauth2.Token, er
 	}
 
 	if oauthResp == nil {
-		return nil, fmt.Errorf("missing oauth credentials in response")
+		return nil, errors.New("missing oauth credentials in response")
 	}
 
 	tok := &oauth2.Token{
diff --git a/internal/memdb/memdb.go b/internal/memdb/memdb.go
@@ -2,7 +2,7 @@ package memdb
 
 import (
 	"context"
-	"fmt"
+	"errors"
 	"sync"
 
 	"github.com/apache/arrow-go/v18/arrow"
@@ -108,7 +108,7 @@ func NewMemDBClient(ctx context.Context, l zerolog.Logger, spec []byte, options
 }
 
 func NewMemDBClientErrOnNew(context.Context, zerolog.Logger, []byte, plugin.NewClientOptions) (plugin.Client, error) {
-	return nil, fmt.Errorf("newTestDestinationMemDBClientErrOnNew")
+	return nil, errors.New("newTestDestinationMemDBClientErrOnNew")
 }
 
 func (c *client) overwrite(table *schema.Table, record arrow.Record) {
@@ -211,12 +211,12 @@ func (c *client) migrate(_ context.Context, table *schema.Table) {
 
 func (c *client) Write(ctx context.Context, msgs <-chan message.WriteMessage) error {
 	if c.errOnWrite {
-		return fmt.Errorf("errOnWrite")
+		return errors.New("errOnWrite")
 	}
 	if c.blockingWrite {
 		<-ctx.Done()
 		if c.errOnWrite {
-			return fmt.Errorf("errOnWrite")
+			return errors.New("errOnWrite")
 		}
 		return nil
 	}
@@ -235,7 +235,7 @@ func (c *client) Write(ctx context.Context, msgs <-chan message.WriteMessage) er
 			sc := msg.Record.Schema()
 			tableName, ok := sc.Metadata().GetValue(schema.MetadataTableName)
 			if !ok {
-				return fmt.Errorf("table name not found in schema metadata")
+				return errors.New("table name not found in schema metadata")
 			}
 			table := c.tables[tableName]
 			c.overwrite(table, msg.Record)
diff --git a/plugin/plugin.go b/plugin/plugin.go
@@ -2,6 +2,7 @@ package plugin
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"sync"
 
@@ -13,7 +14,7 @@ import (
 	"github.com/santhosh-tekuri/jsonschema/v6"
 )
 
-var ErrNotImplemented = fmt.Errorf("not implemented")
+var ErrNotImplemented = errors.New("not implemented")
 
 type NewClientOptions struct {
 	NoConnection bool
@@ -215,7 +216,7 @@ func (p *Plugin) SetLogger(logger zerolog.Logger) {
 
 func (p *Plugin) Tables(ctx context.Context, options TableOptions) (schema.Tables, error) {
 	if p.client == nil {
-		return nil, fmt.Errorf("plugin not initialized")
+		return nil, errors.New("plugin not initialized")
 	}
 	tables, err := p.client.Tables(ctx, options)
 	if err != nil {
@@ -227,7 +228,7 @@ func (p *Plugin) Tables(ctx context.Context, options TableOptions) (schema.Table
 // Init initializes the plugin with the given spec.
 func (p *Plugin) Init(ctx context.Context, spec []byte, options NewClientOptions) error {
 	if !p.mu.TryLock() {
-		return fmt.Errorf("plugin already in use")
+		return errors.New("plugin already in use")
 	}
 	defer p.mu.Unlock()
 	var err error
@@ -257,7 +258,7 @@ func (p *Plugin) Init(ctx context.Context, spec []byte, options NewClientOptions
 
 func (p *Plugin) Close(ctx context.Context) error {
 	if !p.mu.TryLock() {
-		return fmt.Errorf("plugin already in use")
+		return errors.New("plugin already in use")
 	}
 	defer p.mu.Unlock()
 	if p.client == nil {
diff --git a/plugin/plugin_destination.go b/plugin/plugin_destination.go
@@ -2,6 +2,7 @@ package plugin
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/apache/arrow-go/v18/arrow"
@@ -33,19 +34,19 @@ func (p *Plugin) WriteAll(ctx context.Context, resources []message.WriteMessage)
 
 func (p *Plugin) Write(ctx context.Context, res <-chan message.WriteMessage) error {
 	if p.client == nil {
-		return fmt.Errorf("plugin is not initialized. call Init first")
+		return errors.New("plugin is not initialized. call Init first")
 	}
 	return p.client.Write(ctx, res)
 }
 
 // Read is read data from the requested table to the given channel, returned in the same format as the table
 func (p *Plugin) Read(ctx context.Context, table *schema.Table, res chan<- arrow.Record) error {
 	if !p.mu.TryLock() {
-		return fmt.Errorf("plugin already in use")
+		return errors.New("plugin already in use")
 	}
 	defer p.mu.Unlock()
 	if p.client == nil {
-		return fmt.Errorf("plugin not initialized. call Init() first")
+		return errors.New("plugin not initialized. call Init() first")
 	}
 	if err := p.client.Read(ctx, table, res); err != nil {
 		return fmt.Errorf("failed to read: %w", err)
diff --git a/plugin/plugin_source.go b/plugin/plugin_source.go
@@ -2,6 +2,7 @@ package plugin
 
 import (
 	"context"
+	"errors"
 	"fmt"
 
 	"github.com/cloudquery/plugin-sdk/v4/glob"
@@ -88,11 +89,11 @@ func (p *Plugin) SyncAll(ctx context.Context, options SyncOptions) (message.Sync
 // Sync is syncing data from the requested tables in spec to the given channel
 func (p *Plugin) Sync(ctx context.Context, options SyncOptions, res chan<- message.SyncMessage) error {
 	if !p.mu.TryLock() {
-		return fmt.Errorf("plugin already in use")
+		return errors.New("plugin already in use")
 	}
 	defer p.mu.Unlock()
 	if p.client == nil {
-		return fmt.Errorf("plugin not initialized. call Init() first")
+		return errors.New("plugin not initialized. call Init() first")
 	}
 
 	if err := p.client.Sync(ctx, options, res); err != nil {
diff --git a/premium/usage.go b/premium/usage.go
@@ -334,15 +334,15 @@ func awsMarketplaceProductCode() string {
 
 func (u *BatchUpdater) Increase(rows uint32) error {
 	if u.usageIncreaseMethod == UsageIncreaseMethodBreakdown {
-		return fmt.Errorf("mixing usage increase methods is not allowed, use IncreaseForTable instead")
+		return errors.New("mixing usage increase methods is not allowed, use IncreaseForTable instead")
 	}
 
 	if rows <= 0 {
 		return fmt.Errorf("rows must be greater than zero got %d", rows)
 	}
 
 	if u.isClosed {
-		return fmt.Errorf("usage updater is closed")
+		return errors.New("usage updater is closed")
 	}
 
 	u.Lock()
@@ -364,15 +364,15 @@ func (u *BatchUpdater) Increase(rows uint32) error {
 
 func (u *BatchUpdater) IncreaseForTable(table string, rows uint32) error {
 	if u.usageIncreaseMethod == UsageIncreaseMethodTotal {
-		return fmt.Errorf("mixing usage increase methods is not allowed, use Increase instead")
+		return errors.New("mixing usage increase methods is not allowed, use Increase instead")
 	}
 
 	if rows <= 0 {
 		return fmt.Errorf("rows must be greater than zero got %d", rows)
 	}
 
 	if u.isClosed {
-		return fmt.Errorf("usage updater is closed")
+		return errors.New("usage updater is closed")
 	}
 
 	u.Lock()
@@ -696,7 +696,7 @@ func (u *BatchUpdater) getTeamNameByTokenType(tokenType auth.TokenType) (string,
 			return "", fmt.Errorf("failed to get team name from config: %w", err)
 		}
 		if teamName == "" {
-			return "", fmt.Errorf("team name not set. Hint: use `cloudquery switch <team>`")
+			return "", errors.New("team name not set. Hint: use `cloudquery switch <team>`")
 		}
 		return teamName, nil
 	case auth.APIKey:
@@ -716,7 +716,7 @@ func (u *BatchUpdater) getTeamNameByTokenType(tokenType auth.TokenType) (string,
 		if team == "" {
 			switch tokenType {
 			case auth.SyncRunAPIKey, auth.SyncTestConnectionAPIKey:
-				return "", fmt.Errorf("_CQ_TEAM_NAME environment variable not set")
+				return "", errors.New("_CQ_TEAM_NAME environment variable not set")
 			}
 			return "", fmt.Errorf("unsupported token type: %v", tokenType)
 		}
diff --git a/schema/table.go b/schema/table.go
@@ -3,6 +3,7 @@ package schema
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"regexp"
 	"slices"
@@ -177,7 +178,7 @@ func NewTableFromArrowSchema(sc *arrow.Schema) (*Table, error) {
 	tableMD := sc.Metadata()
 	name, found := tableMD.GetValue(MetadataTableName)
 	if !found {
-		return nil, fmt.Errorf("missing table name")
+		return nil, errors.New("missing table name")
 	}
 	description, _ := tableMD.GetValue(MetadataTableDescription)
 	constraintName, _ := tableMD.GetValue(MetadataConstraintName)
diff --git a/serve/package.go b/serve/package.go
diff --git a/writers/batchwriter/batchwriter.go b/writers/batchwriter/batchwriter.go
diff --git a/writers/streamingbatchwriter/streamingbatchwriter.go b/writers/streamingbatchwriter/streamingbatchwriter.go

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ func (t cloudTokenSource) retrieveToken(ctx context.Context) (oauth2.Token, er`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`if oauthResp == nil {`
`117`		`- return nil, fmt.Errorf("missing oauth credentials in response")`
	`117`	`+ return nil, errors.New("missing oauth credentials in response")`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`tok := &oauth2.Token{`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@ package memdb`
`2`	`2`
`3`	`3`	`import (`
`4`	`4`	`"context"`
`5`		`- "fmt"`
	`5`	`+ "errors"`
`6`	`6`	`"sync"`
`7`	`7`
`8`	`8`	`"github.com/apache/arrow-go/v18/arrow"`
`@@ -108,7 +108,7 @@ func NewMemDBClient(ctx context.Context, l zerolog.Logger, spec []byte, options`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`func NewMemDBClientErrOnNew(context.Context, zerolog.Logger, []byte, plugin.NewClientOptions) (plugin.Client, error) {`
`111`		`- return nil, fmt.Errorf("newTestDestinationMemDBClientErrOnNew")`
	`111`	`+ return nil, errors.New("newTestDestinationMemDBClientErrOnNew")`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`func (c client) overwrite(table schema.Table, record arrow.Record) {`
`@@ -211,12 +211,12 @@ func (c client) migrate(_ context.Context, table schema.Table) {`
`211`	`211`
`212`	`212`	`func (c *client) Write(ctx context.Context, msgs <-chan message.WriteMessage) error {`
`213`	`213`	`if c.errOnWrite {`
`214`		`- return fmt.Errorf("errOnWrite")`
	`214`	`+ return errors.New("errOnWrite")`
`215`	`215`	`}`
`216`	`216`	`if c.blockingWrite {`
`217`	`217`	`<-ctx.Done()`
`218`	`218`	`if c.errOnWrite {`
`219`		`- return fmt.Errorf("errOnWrite")`
	`219`	`+ return errors.New("errOnWrite")`
`220`	`220`	`}`
`221`	`221`	`return nil`
`222`	`222`	`}`
`@@ -235,7 +235,7 @@ func (c *client) Write(ctx context.Context, msgs <-chan message.WriteMessage) er`
`235`	`235`	`sc := msg.Record.Schema()`
`236`	`236`	`tableName, ok := sc.Metadata().GetValue(schema.MetadataTableName)`
`237`	`237`	`if !ok {`
`238`		`- return fmt.Errorf("table name not found in schema metadata")`
	`238`	`+ return errors.New("table name not found in schema metadata")`
`239`	`239`	`}`
`240`	`240`	`table := c.tables[tableName]`
`241`	`241`	`c.overwrite(table, msg.Record)`