ernie-research/MEnvData-SWE huggingface dataset:
Repository: fluent/fluent-bit (C)

Issue:
Filter plugin name is case sensitive
## Bug Report

**Describe the bug**
<!--- A clear and concise description of what the bug is. -->

Fluent-bit allows case-sensitive filter plugin name.
e.g. `recOrd_ModiFier` is not allowed.

On the other hand, fluent-bit allows case-insensitive input/output plugin name.

**To Reproduce**
- Rubular link if applicable:None
- Example log message if applicable: None

- Steps to reproduce the problem:`fluent-bit -i cpu -o null -F Stdout -m '*'`

**Expected behavior**
<!--- A clear and concise description of what you expected to happen. -->

Allow case-insensitive filter plugin name.

**Screenshots**
<!--- If applicable, add screenshots to help explain your problem. -->

**Your Environment**
<!--- Include as many relevant details about the environment you experienced the bug in -->
* Version used: v1.8.11
* Configuration: None
* Environment name and version (e.g. Kubernetes? What version?): Ubuntu 20.04
* Server type and version: Ubuntu 20.04
* Operating System and version: Ubuntu 20.04
* Filters and plugins: stdout

**Additional context**
<!--- How has this issue affected you? What are you trying to accomplish? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->

Below config is valid.
It means `mEm` and `stDOut` are allowed.
```
[INPUT]
    Name mEm

[OUTPUT]
    Name stDOut
    Match *
```



Discussion:

Patch:
diff --git a/src/flb_filter.c b/src/flb_filter.c
index 3afbadfdfd6..43af1e14731 100644
--- a/src/flb_filter.c
+++ b/src/flb_filter.c
@@ -316,7 +316,7 @@ struct flb_filter_instance *flb_filter_new(struct flb_config *config,
 
     mk_list_foreach(head, &config->filter_plugins) {
         plugin = mk_list_entry(head, struct flb_filter_plugin, _head);
-        if (strcmp(plugin->name, filter) == 0) {
+        if (strcasecmp(plugin->name, filter) == 0) {
             break;
         }
         plugin = NULL;


Test patch:
diff --git a/tests/runtime/filter_stdout.c b/tests/runtime/filter_stdout.c
index 886faf8a193..8d75c155a6e 100644
--- a/tests/runtime/filter_stdout.c
+++ b/tests/runtime/filter_stdout.c
@@ -7,13 +7,36 @@
 
 /* Test functions */
 void flb_test_filter_stdout_json_multiple(void);
+void flb_test_filter_stdout_case_insensitive(void);
 
 /* Test list */
 TEST_LIST = {
     {"json_multiple", flb_test_filter_stdout_json_multiple },
+    {"case_insensitive_name", flb_test_filter_stdout_case_insensitive},
     {NULL, NULL}
 };
 
+/* 
+ * This test case is to check if fluent-bit allows case-insensitive plugin name.
+ * This test is not unique to filter_stdout, but we test here :) ,
+ */
+
+void flb_test_filter_stdout_case_insensitive(void)
+{
+    int filter_ffd;
+    char filter_name[] = "stDoUt";
+    flb_ctx_t *ctx;
+
+    ctx = flb_create();
+
+    filter_ffd = flb_filter(ctx, (char *) filter_name, NULL);
+    if(!TEST_CHECK(filter_ffd >= 0)) {
+        TEST_MSG("%s should be valid\n", filter_name);
+    }
+
+    flb_destroy(ctx);
+}
+
 void flb_test_filter_stdout_json_multiple(void)
 {
     int i;
Repository: gogf/gf (Go)

Issue:
Nested use of gvar can lead to a panic error.
`
data := gvar.New(gvar.New("asd"))
data.IsMap()
`
panic: reflect: call of reflect.Value.Elem on struct Value [recovered]
	panic: reflect: call of reflect.Value.Elem on struct Value

painc in /github.com/gogf/gf/v2@v2.5.2/internal/utils/utils_is.go:75 

<img width="478" alt="image" src="https://github.com/gogf/gf/assets/112787538/f184ca58-ec6a-4183-ab82-b10e247bdaf4">



Discussion:

Patch:
diff --git a/internal/utils/utils_is.go b/internal/utils/utils_is.go
index 39d450e83bd..e7fa2e3388f 100644
--- a/internal/utils/utils_is.go
+++ b/internal/utils/utils_is.go
@@ -74,6 +74,7 @@ func IsMap(value interface{}) bool {
 	)
 	for reflectKind == reflect.Ptr {
 		reflectValue = reflectValue.Elem()
+		reflectKind = reflectValue.Kind()
 	}
 	switch reflectKind {
 	case reflect.Map:


Test patch:
diff --git a/container/gvar/gvar_z_unit_is_test.go b/container/gvar/gvar_z_unit_is_test.go
index c1b9daae7e9..b3ce85dfbf7 100644
--- a/container/gvar/gvar_z_unit_is_test.go
+++ b/container/gvar/gvar_z_unit_is_test.go
@@ -9,6 +9,7 @@ package gvar_test
 import (
 	"testing"
 
+	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
 )
@@ -144,6 +145,10 @@ func TestVar_IsMap(t *testing.T) {
 		t.Assert(g.NewVar(int8(1)).IsMap(), false)
 		t.Assert(g.NewVar(uint8(1)).IsMap(), false)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gvar.New(gvar.New("asd")).IsMap(), false)
+		t.Assert(gvar.New(&g.Map{"k": "v"}).IsMap(), true)
+	})
 }
 
 func TestVar_IsStruct(t *testing.T) {
Repository: 99designs/gqlgen (Go)

Issue:
HasOperationContext does not fully protect GetOperationContext
### What happened?

When calling `HasOperationContext`
to check if there is a valid operation context,
`GetOperationContext` will panic despite
`HasOperationContext` returning true.

### What did you expect?

When calling `HasOperationContext`
to check if there is a valid operation context,
`GetOperationContext` will _never_ panic when
`HasOperationContext` returns true.

### Minimal graphql.schema and models to reproduce

n/a

### versions
 - `go run github.com/99designs/gqlgen version`?
 - `go version`?
 
`v0.17.31`



Discussion:

Patch:
diff --git a/graphql/context_operation.go b/graphql/context_operation.go
index 77a42b84b74..3e6a221b0b4 100644
--- a/graphql/context_operation.go
+++ b/graphql/context_operation.go
@@ -73,8 +73,8 @@ func WithOperationContext(ctx context.Context, rc *OperationContext) context.Con
 //
 // Some errors can happen outside of an operation, eg json unmarshal errors.
 func HasOperationContext(ctx context.Context) bool {
-	_, ok := ctx.Value(operationCtx).(*OperationContext)
-	return ok
+	val, ok := ctx.Value(operationCtx).(*OperationContext)
+	return ok && val != nil
 }
 
 // This is just a convenient wrapper method for CollectFields


Test patch:
diff --git a/graphql/context_operation_test.go b/graphql/context_operation_test.go
index 4ce374601f7..cd4e61e7163 100644
--- a/graphql/context_operation_test.go
+++ b/graphql/context_operation_test.go
@@ -3,11 +3,33 @@ package graphql
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 	"github.com/vektah/gqlparser/v2/ast"
 )
 
+// implement context.Context interface
+type testGraphRequestContext struct {
+	opContext *OperationContext
+}
+
+func (t *testGraphRequestContext) Deadline() (deadline time.Time, ok bool) {
+	return time.Time{}, false
+}
+
+func (t *testGraphRequestContext) Done() <-chan struct{} {
+	return nil
+}
+
+func (t *testGraphRequestContext) Err() error {
+	return nil
+}
+
+func (t *testGraphRequestContext) Value(key interface{}) interface{} {
+	return t.opContext
+}
+
 func TestGetOperationContext(t *testing.T) {
 	rc := &OperationContext{}
 
@@ -26,6 +48,15 @@ func TestGetOperationContext(t *testing.T) {
 			GetOperationContext(ctx)
 		})
 	})
+
+	t.Run("with nil operation context", func(t *testing.T) {
+		ctx := &testGraphRequestContext{opContext: nil}
+
+		require.False(t, HasOperationContext(ctx))
+		require.Panics(t, func() {
+			GetOperationContext(ctx)
+		})
+	})
 }
 
 func TestCollectAllFields(t *testing.T) {
Repository: GoogleCloudPlatform/cloud-sql-proxy (Go)

Issue:
Allow HTTP GET to /quitquitquit admin api for k8s compatibility
### Feature Description

Kubernetes pod [lifecycle handler](https://kubernetes.io/docs/reference/kubernetes-api/workload-resources/pod-v1/#LifecycleHandler) allows the kubernetes api to make an HTTP GET request to a pod after the pod starts up or shuts down. This could be used to gracefully terminate the proxy when another container on the pod exits. 

However, the proxy will only respond to HTTP POST requests to /quitquitquit. K8s lifecycle handler cannot make a POST request. 

So in order to use the lifecycle handler, the proxy /quitquitquit endpoint should respond to both GET and POST request.



Discussion:

Patch:
diff --git a/cmd/root.go b/cmd/root.go
index c7f931e9e..f1c63cec8 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -913,7 +913,7 @@ func runSignalWrapper(cmd *Command) (err error) {
 
 func quitquitquit(quitOnce *sync.Once, shutdownCh chan<- error) http.HandlerFunc {
 	return func(rw http.ResponseWriter, req *http.Request) {
-		if req.Method != http.MethodPost {
+		if req.Method != http.MethodPost && req.Method != http.MethodGet {
 			rw.WriteHeader(400)
 			return
 		}


Test patch:
diff --git a/cmd/root_test.go b/cmd/root_test.go
index b2f60b02c..1607e7164 100644
--- a/cmd/root_test.go
+++ b/cmd/root_test.go
@@ -1307,7 +1307,7 @@ func TestPProfServer(t *testing.T) {
 	}
 }
 
-func TestQuitQuitQuit(t *testing.T) {
+func TestQuitQuitQuitHTTPPost(t *testing.T) {
 	c := NewCommand(WithDialer(&spyDialer{}))
 	c.SilenceUsage = true
 	c.SilenceErrors = true
@@ -1320,7 +1320,7 @@ func TestQuitQuitQuit(t *testing.T) {
 		err := c.ExecuteContext(ctx)
 		errCh <- err
 	}()
-	resp, err := tryDial("GET", "http://localhost:9192/quitquitquit")
+	resp, err := tryDial("HEAD", "http://localhost:9192/quitquitquit")
 	if err != nil {
 		t.Fatalf("failed to dial endpoint: %v", err)
 	}
@@ -1348,6 +1348,41 @@ func TestQuitQuitQuit(t *testing.T) {
 	}
 }
 
+func TestQuitQuitQuitHTTPGet(t *testing.T) {
+	c := NewCommand(WithDialer(&spyDialer{}))
+	c.SilenceUsage = true
+	c.SilenceErrors = true
+	c.SetArgs([]string{"--quitquitquit", "--admin-port", "9194", "my-project:my-region:my-instance"})
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	errCh := make(chan error)
+	go func() {
+		err := c.ExecuteContext(ctx)
+		errCh <- err
+	}()
+
+	resp, err := tryDial("GET", "http://localhost:9194/quitquitquit")
+	if err != nil {
+		t.Fatalf("failed to dial endpoint: %v", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("expected a 200 status, got = %v", resp.StatusCode)
+	}
+
+	var gotErr error
+	select {
+	case err := <-errCh:
+		gotErr = err
+	case <-time.After(30 * time.Second):
+		t.Fatal("timeout waiting for error")
+	}
+
+	if !errors.Is(gotErr, errQuitQuitQuit) {
+		t.Fatalf("want = %v, got = %v", errQuitQuitQuit, gotErr)
+	}
+}
+
 type errorDialer struct {
 	spyDialer
 }
Repository: stretchr/testify (Go)

Issue:
`suite.Require` deadlock 
If `require` object hasn't been initialized before calling `suite.Require` method, it will be created on the base of  `*testing.T` returned from  `suite.T()` ([code](https://github.com/stretchr/testify/blame/v1.8.4/suite/suite.go#L61)):

```go
// Require returns a require context for suite.
func (suite *Suite) Require() *require.Assertions {
	suite.mu.Lock()
	defer suite.mu.Unlock()
	if suite.require == nil {
		suite.require = require.New(suite.T())
	}
	return suite.require
}
```

This will result in a deadlock because `suite.T()` wants to acquire the lock that has been already acquired:

```go
// T retrieves the current *testing.T context.
func (suite *Suite) T() *testing.T {
	suite.mu.RLock()
	defer suite.mu.RUnlock()
	return suite.t
}
```


Discussion:
Thanks for reporting this @vitalyisaev2!

I've put up a PR for fixing this. If you have any thoughts about the approach, please comment on #1535 



Patch:
diff --git a/suite/suite.go b/suite/suite.go
index eac6909b4..18443a91c 100644
--- a/suite/suite.go
+++ b/suite/suite.go
@@ -58,7 +58,7 @@ func (suite *Suite) Require() *require.Assertions {
 	suite.mu.Lock()
 	defer suite.mu.Unlock()
 	if suite.require == nil {
-		suite.require = require.New(suite.T())
+		panic("'Require' must not be called before 'Run' or 'SetT'")
 	}
 	return suite.require
 }
@@ -72,7 +72,7 @@ func (suite *Suite) Assert() *assert.Assertions {
 	suite.mu.Lock()
 	defer suite.mu.Unlock()
 	if suite.Assertions == nil {
-		suite.Assertions = assert.New(suite.T())
+		panic("'Assert' must not be called before 'Run' or 'SetT'")
 	}
 	return suite.Assertions
 }


Test patch:
diff --git a/suite/suite_test.go b/suite/suite_test.go
index 292dc298c..b31eb3596 100644
--- a/suite/suite_test.go
+++ b/suite/suite_test.go
@@ -692,3 +692,27 @@ func TestSubtestPanic(t *testing.T) {
 	assert.True(t, suite.inTearDownTest)
 	assert.True(t, suite.inTearDownSuite)
 }
+
+type unInitialisedSuite struct {
+	Suite
+}
+
+// TestUnInitialisedSuites asserts the behaviour of the suite methods when the
+// suite is not initialised
+func TestUnInitialisedSuites(t *testing.T) {
+	t.Run("should panic on Require", func(t *testing.T) {
+		suite := new(unInitialisedSuite)
+
+		assert.Panics(t, func() {
+			suite.Require().True(true)
+		})
+	})
+
+	t.Run("should panic on Assert", func(t *testing.T) {
+		suite := new(unInitialisedSuite)
+
+		assert.Panics(t, func() {
+			suite.Assert().True(true)
+		})
+	})
+}
Repository: ent/ent (Go)

Issue:
CreateBulk doesn't error on unique constraint
<!-- Provide a general summary of the issue in the Title above -->
CreateBulk doesn't error nor insert data on unique constraint when used with SQLite.

<!--
  Thank you very much for contributing to Ent by creating an issue! ❤️
  To avoid duplicate issues we ask you to check off the following list.
-->

<!-- Checked checkbox should look like this: [x] -->

- [X] The issue is present in the latest release.
- [X] I have searched the [issues](https://github.com/ent/ent/issues) of this repository and believe that this is not a duplicate.

## Steps to Reproduce 🕹
reproduction repo [here](https://github.com/oSethoum/ent-constraint-sqlite-bug)
<!-- 
  Are you able to reproduce this bug? If so, follow the steps in the ent/bug repository: https://github.com/ent/bug
  After you are done, paste the link to your new repository here (make sure it's public)!
  (In this case, you can disregard filling out the steps below)
 -->


<!--
  TODO: reproduction repo
-->


## Your Environment 🌎

<!--
  Include as many relevant details about the environment with which you experienced the bug.
-->

| Tech        | Version |
| ----------- | ------- |
| Go          | 1.20.2  |
| Ent         | 0.11.8   |
| Database    | SQLite |
| Driver      | https://github.com/mattn/go-sqlite3 |



Discussion:
Thanks a lot for reporting this, @oSethoum. The issue was fixed with https://github.com/ent/ent/pull/3415.



Patch:
diff --git a/dialect/sql/sqlgraph/graph.go b/dialect/sql/sqlgraph/graph.go
index 246886c70f..af92d399f1 100644
--- a/dialect/sql/sqlgraph/graph.go
+++ b/dialect/sql/sqlgraph/graph.go
@@ -1630,7 +1630,7 @@ func (c *batchCreator) insertLastIDs(ctx context.Context, tx dialect.ExecQuerier
 				return err
 			}
 		}
-		return nil
+		return rows.Err()
 	}
 	// MySQL.
 	var res sql.Result


Test patch:
diff --git a/entc/integration/integration_test.go b/entc/integration/integration_test.go
index 80cb3dacad..7212a92223 100644
--- a/entc/integration/integration_test.go
+++ b/entc/integration/integration_test.go
@@ -1498,6 +1498,11 @@ func UniqueConstraint(t *testing.T, client *ent.Client) {
 	require.True(ent.IsConstraintError(err))
 	err = client.User.UpdateOne(foo).SetNickname("bar").SetPhone("2").Exec(ctx)
 	require.True(ent.IsConstraintError(err))
+	err = client.User.CreateBulk(
+		client.User.Create().SetAge(1).SetName("foo").SetNickname("baz"),
+		client.User.Create().SetAge(1).SetName("foo").SetNickname("baz"),
+	).Exec(ctx)
+	require.True(ent.IsConstraintError(err))
 
 	t.Log("o2o unique constraint on creation")
 	dan := client.User.Create().SetAge(1).SetName("dan").SetNickname("dan").SetSpouse(foo).SaveX(ctx)
Repository: kubernetes-sigs/controller-runtime (Go)

Issue:
TerminalError(nil).Error() panics
In v0.15.0
Code to trigger:
```
package main

import (
	"fmt"
	"sigs.k8s.io/controller-runtime/pkg/reconcile"
)

func main() {
	te_nil := reconcile.TerminalError(nil)
	// te_nil = reconcile.TerminalError(fmt.Errorf("nil"))
	fmt.Print(te_nil.Error())
}
```

`TerminalError(nil)` is being used to create errors here: https://github.com/kubernetes-sigs/controller-runtime/blob/7f0c6dc440f334849b25866dd9990ac1a5a777c2/pkg/internal/controller/controller.go#L319

This specifically causes problems when used with the Eris error logger:
```
package main

import (
	"errors"
	"fmt"

	"github.com/rotisserie/eris"
	"sigs.k8s.io/controller-runtime/pkg/reconcile"
)

func main() {
	err := eris.New("some error")

	if errors.Is(err, reconcile.TerminalError(nil)) {
		fmt.Print("Error is nil")
	} else {
		fmt.Print("Error is not nil")
	}
}
```
results in 
```
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x18 pc=0x48cafb]

goroutine 1 [running]:
sigs.k8s.io/controller-runtime/pkg/reconcile.(*terminalError).Error(0x49c0e0?)
	/tmp/gopath2655630741/pkg/mod/sigs.k8s.io/controller-runtime@v0.15.0/pkg/reconcile/reconcile.go:120 +0x1b
github.com/rotisserie/eris.(*rootError).Is(0xc0000161e0, {0x4c57e8?, 0xc000014280?})
	/tmp/gopath2655630741/pkg/mod/github.com/rotisserie/eris@v0.5.4/eris.go:216 +0x73
errors.Is({0x4c5748, 0xc0000161e0}, {0x4c57e8, 0xc000014280})
	/usr/local/go-faketime/src/errors/wrap.go:53 +0x156
main.main()
	/tmp/sandbox73597216/prog.go:17 +0x5c
```

Proposed change:
Code to check for nil in https://github.com/kubernetes-sigs/controller-runtime/blob/7f0c6dc440f334849b25866dd9990ac1a5a777c2/pkg/reconcile/reconcile.go#L119

along the lines of:
```
func (te *terminalError) Error() string {
	if te.err == nil {
		return "nil terminal error"
	}
	return "terminal error: " + te.err.Error()
}
```



Discussion:

Patch:
diff --git a/pkg/reconcile/reconcile.go b/pkg/reconcile/reconcile.go
index d51cfc34ab..4c8f8357a5 100644
--- a/pkg/reconcile/reconcile.go
+++ b/pkg/reconcile/reconcile.go
@@ -112,11 +112,15 @@ type terminalError struct {
 	err error
 }
 
+// This function will return nil if te.err is nil.
 func (te *terminalError) Unwrap() error {
 	return te.err
 }
 
 func (te *terminalError) Error() string {
+	if te.err == nil {
+		return "nil terminal error"
+	}
 	return "terminal error: " + te.err.Error()
 }
 


Test patch:
diff --git a/pkg/reconcile/reconcile_test.go b/pkg/reconcile/reconcile_test.go
index b5660f1b4f..9373d5ed5c 100644
--- a/pkg/reconcile/reconcile_test.go
+++ b/pkg/reconcile/reconcile_test.go
@@ -96,5 +96,10 @@ var _ = Describe("reconcile", func() {
 
 			Expect(apierrors.IsGone(terminalError)).To(BeTrue())
 		})
+
+		It("should handle nil terminal errors properly", func() {
+			err := reconcile.TerminalError(nil)
+			Expect(err.Error()).To(Equal("nil terminal error"))
+		})
 	})
 })
Repository: dolthub/go-mysql-server (Go)

Issue:
Update MySQL version to 8.0.31 so that Django recognizes support for INTERSECT and EXCEPT?
- Dolt currently reports its MySQL version as `8.0.23`
- Dolt added support for `INTERSECT` and `EXCEPT` in #2005.
- MySQL added support for `INTERSECT` and `EXCEPT` in version `8.0.31` (https://dev.mysql.com/doc/relnotes/mysql/8.0/en/news-8-0-31.html)
- Because of this, Django believes that any (non-MariaDB) MySQL version less than `8.0.31` does *not* support these operators (https://github.com/django/django/blob/stable/4.2.x/django/db/backends/mysql/features.py#L336-L343) and therefore throws a `django.db.utils.NotSupportedError` when attempting to use these operators with a Dolt database.

Would it be possible and reasonable to bump the Dolt MySQL version to `8.0.31` to make Django permit the use of these operators, or does that pose its own set of problems?


Discussion:
Sure. @jycor will change this today.
Hey @glennmatthews, thanks for reporting this. The fix is merged in and we'll cut a release for you with the change today!
Thank you as always for the speedy resolution! Much appreciated.



Patch:
diff --git a/sql/variables/system_variables.go b/sql/variables/system_variables.go
index e09f021b6f..e515ba6134 100644
--- a/sql/variables/system_variables.go
+++ b/sql/variables/system_variables.go
@@ -2951,7 +2951,7 @@ var systemVars = map[string]sql.SystemVariable{
 		Dynamic:           false,
 		SetVarHintApplies: false,
 		Type:              types.NewSystemStringType("version"),
-		Default:           "8.0.23",
+		Default:           "8.0.31",
 	},
 	"version_comment": &sql.MysqlSystemVariable{
 		Name:              "version_comment",


Test patch:
diff --git a/enginetest/queries/queries.go b/enginetest/queries/queries.go
index e1c4a0d57a..468e0402ad 100644
--- a/enginetest/queries/queries.go
+++ b/enginetest/queries/queries.go
@@ -5429,7 +5429,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: "SELECT version()",
 		Expected: []sql.Row{
-			{"8.0.23"},
+			{"8.0.31"},
 		},
 	},
 	{
@@ -5825,7 +5825,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: `SHOW VARIABLES WHERE Variable_name = 'version' || variable_name = 'autocommit'`,
 		Expected: []sql.Row{
-			{"autocommit", 1}, {"version", "8.0.23"},
+			{"autocommit", 1}, {"version", "8.0.31"},
 		},
 	},
 	{
@@ -5865,7 +5865,7 @@ SELECT * FROM cte WHERE  d = 2;`,
 	{
 		Query: "SHOW VARIABLES LIKE 'VERSION'",
 		Expected: []sql.Row{
-			{"version", "8.0.23"},
+			{"version", "8.0.31"},
 		},
 	},
 	{
diff --git a/sql/expression/function/version_test.go b/sql/expression/function/version_test.go
index fe87f3c3eb..acaf8347e2 100644
--- a/sql/expression/function/version_test.go
+++ b/sql/expression/function/version_test.go
@@ -32,12 +32,12 @@ func TestNewVersion(t *testing.T) {
 
 	val, err := f.Eval(ctx, nil)
 	require.NoError(err)
-	require.Equal("8.0.23-"+versionPostfix, val)
+	require.Equal("8.0.31-"+versionPostfix, val)
 
 	f, err = NewVersion("")()
 	require.NoError(err)
 
 	val, err = f.Eval(ctx, nil)
 	require.NoError(err)
-	require.Equal("8.0.23", val)
+	require.Equal("8.0.31", val)
 }
Repository: google/go-github (Go)

Issue:
Add Topics to PushEventRepository
I would like to leverage the `topics` field found in the `repository` object of several webhook event payloads. I noticed that for the `push` event, which has a [special repo struct](https://github.com/google/go-github/blob/c96ba417f7b022bee92bc04d831e89fd9fc70edc/github/event_types.go#L1028-L1065), the `Topics` field was missing. 

I plan on implementing this enhancement the same way the standard [repository](https://github.com/google/go-github/blob/c96ba417f7b022bee92bc04d831e89fd9fc70edc/github/repos.go#L78) struct does it, unless there are any objections. I am curious why it is of type `[]string` and not `*[]string` though, if anyone would be willing to clarify that for me? It doesn't get an accessor generated as a result.



Discussion:
We typically only use a pointer to a slice when it is important in the GitHub v3 API to accurately distinguish between when the slice is provided and when it is not. Otherwise, we typically use just a slice since they are easier to deal with.

Yes, PRs to add missing fields are welcome, thank you!



Patch:
diff --git a/github/event_types.go b/github/event_types.go
index 598d98d48c3..71dfd2d0a02 100644
--- a/github/event_types.go
+++ b/github/event_types.go
@@ -1062,6 +1062,7 @@ type PushEventRepository struct {
 	SSHURL          *string    `json:"ssh_url,omitempty"`
 	CloneURL        *string    `json:"clone_url,omitempty"`
 	SVNURL          *string    `json:"svn_url,omitempty"`
+	Topics          []string   `json:"topics,omitempty"`
 }
 
 // PushEventRepoOwner is a basic representation of user/org in a PushEvent payload.


Test patch:
diff --git a/github/event_types_test.go b/github/event_types_test.go
index 7c84146f460..a2628b85378 100644
--- a/github/event_types_test.go
+++ b/github/event_types_test.go
@@ -12271,6 +12271,7 @@ func TestPushEventRepository_Marshal(t *testing.T) {
 		SSHURL:          String("s"),
 		CloneURL:        String("c"),
 		SVNURL:          String("s"),
+		Topics:          []string{"octocat", "api"},
 	}
 
 	want := `{
@@ -12325,8 +12326,9 @@ func TestPushEventRepository_Marshal(t *testing.T) {
 		"git_url": "g",
 		"ssh_url": "s",
 		"clone_url": "c",
-		"svn_url": "s"
-	}`
+		"svn_url": "s",
+		"topics": ["octocat","api"]
+    }`
 
 	testJSONMarshal(t, u, want)
 }
Repository: corazawaf/coraza (Go)

Issue:
ForceRequestBodyVariable changes the body processor
We are forcing RBP into URLENCODED
```go
rbp = "URLENCODED"
```

We should add a condition, so we only force rbp if rbp is empty:
```go
	if tx.ForceRequestBodyVariable {
		// We force URLENCODED if mime is x-www... or we have an empty RBP and ForceRequestBodyVariable
		if rbp == "" {
			rbp = "URLENCODED"
		}
		tx.variables.reqbodyProcessor.Set(rbp)
	}
```


Discussion:

Patch:
diff --git a/internal/corazawaf/transaction.go b/internal/corazawaf/transaction.go
index a6bceda2f..88cc24b67 100644
--- a/internal/corazawaf/transaction.go
+++ b/internal/corazawaf/transaction.go
@@ -943,7 +943,9 @@ func (tx *Transaction) ProcessRequestBody() (*types.Interruption, error) {
 	// XML and JSON must be forced with ctl:requestBodyProcessor=JSON
 	if tx.ForceRequestBodyVariable {
 		// We force URLENCODED if mime is x-www... or we have an empty RBP and ForceRequestBodyVariable
-		rbp = "URLENCODED"
+		if rbp == "" {
+			rbp = "URLENCODED"
+		}
 		tx.variables.reqbodyProcessor.Set(rbp)
 	}
 	rbp = strings.ToLower(rbp)


Test patch:
diff --git a/internal/corazawaf/transaction_test.go b/internal/corazawaf/transaction_test.go
index 8cea176e9..9be0adbf7 100644
--- a/internal/corazawaf/transaction_test.go
+++ b/internal/corazawaf/transaction_test.go
@@ -1320,3 +1320,33 @@ func TestTxAddResponseArgs(t *testing.T) {
 	tx.AddResponseArgument("samplekey", "samplevalue")
 	t.Log("This is a placeholder for tx.AddResponseArgs")
 }
+
+func TestForceRequestBodyOverride(t *testing.T) {
+	waf := NewWAF()
+	waf.RequestBodyAccess = true
+	tx := waf.NewTransaction()
+	tx.ForceRequestBodyVariable = true
+	tx.variables.RequestBodyProcessor().Set("JSON")
+	tx.ProcessRequestHeaders()
+	if _, _, err := tx.WriteRequestBody([]byte("foo=bar&baz=qux")); err != nil {
+		t.Errorf("Failed to write request body: %v", err)
+	}
+	if _, err := tx.ProcessRequestBody(); err != nil {
+		t.Errorf("Failed to process request body: %v", err)
+	}
+	if tx.variables.RequestBodyProcessor().Get() != "JSON" {
+		t.Errorf("Failed to force request body variable")
+	}
+	tx = waf.NewTransaction()
+	tx.ForceRequestBodyVariable = true
+	tx.ProcessRequestHeaders()
+	if _, _, err := tx.WriteRequestBody([]byte("foo=bar&baz=qux")); err != nil {
+		t.Errorf("Failed to write request body: %v", err)
+	}
+	if _, err := tx.ProcessRequestBody(); err != nil {
+		t.Errorf("Failed to process request body: %v", err)
+	}
+	if tx.variables.RequestBodyProcessor().Get() != "URLENCODED" {
+		t.Errorf("Failed to force request body variable, got RBP: %q", tx.variables.RequestBodyProcessor().Get())
+	}
+}
Repository: 0xERR0R/blocky (Go)

Issue:
Allow `||` in blocklist and whitelist
Currently blocklist and whitelist error out if `||` is found.
Which is a common syntax in blocklists meaning "process as normal host-file entry"

From a technical perspective, all `||` should just be imported without the `||`, instead of erroring or warning.

An example of this is:
https://v.firebog.net/hosts/RPiList-Phishing.txt

Which would, otherwise, be quite-well processable

```
[2025-02-27 12:12:45]  WARN list_cache: parse error: line 6: 3 errors occurred:
	* invalid domain name: ||0-01x-merchandise.554217.xyz^
	* invalid ip: ||0-01x-merchandise.554217.xyz^
	* unsupported wildcard '||0-01x-merchandise.554217.xyz^': must start with '*.' and contain no other '*'

, trying to continue count=0 source=https://v.firebog.net/hosts/RPiList-Phishing.txt
```


Discussion:
blocky supports either the hosts format or wildcard/regex (see https://0xerr0r.github.io/blocky/latest/configuration/#definition-allowdenylists). The list you linked is in Adblock plus format.



Patch:
diff --git a/lists/parsers/hosts.go b/lists/parsers/hosts.go
index 5bcea83dc..d3c0a9aa8 100644
--- a/lists/parsers/hosts.go
+++ b/lists/parsers/hosts.go
@@ -247,6 +247,10 @@ func normalizeHostsListEntry(host string) (string, error) {
 		}
 	}
 
+	// remove optional start and end markers for ABP styled lists
+	host = strings.TrimPrefix(host, "||")
+	host = strings.TrimSuffix(host, "^")
+
 	if err := validateHostsListEntry(host); err != nil {
 		return "", err
 	}


Test patch:
diff --git a/lists/parsers/hosts_test.go b/lists/parsers/hosts_test.go
index 425a71296..29b6f12bb 100644
--- a/lists/parsers/hosts_test.go
+++ b/lists/parsers/hosts_test.go
@@ -37,6 +37,7 @@ var _ = Describe("Hosts", func() {
 				`/^(.*\.)?2023\.xn--aptslabs-6fd\.net$/`,
 				`müller.com`,
 				`*.example.com`,
+				`||0-c1j0.lat^`,
 			)
 		})
 
@@ -76,11 +77,16 @@ var _ = Describe("Hosts", func() {
 			Expect(iteratorToList(it.ForEach)).Should(Equal([]string{"*.example.com"}))
 			Expect(sut.Position()).Should(Equal("line 9"))
 
+			it, err = sut.Next(context.Background())
+			Expect(err).Should(Succeed())
+			Expect(iteratorToList(it.ForEach)).Should(Equal([]string{"0-c1j0.lat"}))
+			Expect(sut.Position()).Should(Equal("line 10"))
+
 			_, err = sut.Next(context.Background())
 			Expect(err).Should(HaveOccurred())
 			Expect(err).Should(MatchError(io.EOF))
 			Expect(IsNonResumableErr(err)).Should(BeTrue())
-			Expect(sut.Position()).Should(Equal("line 10"))
+			Expect(sut.Position()).Should(Equal("line 11"))
 		})
 	})
Repository: bazel-contrib/bazel-gazelle (Go)

Issue:
Gazelle's label validator for repo name is too strict
### What version of gazelle are you using?

v0.25.1

### What version of rules_go are you using?

n/a

### What version of Bazel are you using?

6.1.2

### Does this issue reproduce with the latest releases of all the above?

Yes

### What operating system and processor architecture are you using?

Linux x86_64 and Mac x86_64 and Mac arm64

### What did you do?

Using target-determinator with Bazel 6 and rules_python configured via bzlmod results in a parse error of the rules_python repo names. target-determinator depends on Gazelle's label.Parse function to read labels. (Cross-linking issue filed there: https://github.com/bazel-contrib/target-determinator/issues/59).

### What did you expect to see?

No error, Bazel and rules_python are perfectly happy with a tilde in the repo name.

### What did you see instead?

```
label parse error: repository has invalid characters: "@rules_python~0.21.0~pip~pip//:boto3_pkg
```

See also: https://github.com/bazelbuild/bazel-gazelle/pull/1508 -- though at time of posting this doesn't touch the repo regex.


Discussion:

Patch:
diff --git a/label/label.go b/label/label.go
index ef058b0c0..c2aed9840 100644
--- a/label/label.go
+++ b/label/label.go
@@ -62,7 +62,8 @@ func New(repo, pkg, name string) Label {
 var NoLabel = Label{}
 
 var (
-	labelRepoRegexp = regexp.MustCompile(`^@$|^[A-Za-z.-][A-Za-z0-9_.-]*$`)
+	// This was taken from https://github.com/bazelbuild/bazel/blob/71fb1e4188b01e582a308cfe4bcbf1c730eded1b/src/main/java/com/google/devtools/build/lib/cmdline/RepositoryName.java#L159C1-L164
+	labelRepoRegexp = regexp.MustCompile(`^@$|^[A-Za-z0-9_.-][A-Za-z0-9_.~-]*$`)
 	labelPkgRegexp  = regexp.MustCompile(`^[A-Za-z0-9/._@-]*$`)
 	// This was taken from https://docs.bazel.build/versions/main/build-ref.html#name
 	labelNameRegexp = regexp.MustCompile("^[A-Za-z0-9!%-@^_` \"#$&'()*-+,;<=>?\\[\\]{|}~/.]*$")


Test patch:
diff --git a/label/label_test.go b/label/label_test.go
index c4bf5a0a2..82443b9e4 100644
--- a/label/label_test.go
+++ b/label/label_test.go
@@ -82,6 +82,8 @@ func TestParse(t *testing.T) {
 		{str: "@go_sdk//:src/cmd/go/testdata/mod/rsc.io_!q!u!o!t!e_v1.5.2.txt", want: Label{Repo: "go_sdk", Name: "src/cmd/go/testdata/mod/rsc.io_!q!u!o!t!e_v1.5.2.txt"}},
 		{str: "//:a][b", want: Label{Name: "a][b"}},
 		{str: "//:a b", want: Label{Name: "a b"}},
+		{str: "@rules_python~0.0.0~pip~name_dep//:_pkg", want: Label{Repo: "rules_python~0.0.0~pip~name_dep", Name: "_pkg"}},
+		{str: "@rules_python~0.0.0~pip~name//:dep_pkg", want: Label{Repo: "rules_python~0.0.0~pip~name", Name: "dep_pkg"}},
 	} {
 		got, err := Parse(tc.str)
 		if err != nil && !tc.wantErr {
Repository: ollama/ollama (Go)

Issue:
Get list models is broken
### What is the issue?

The `ollama list` command and `/api/tags` request do not return models list.

Firstly - ollama try to find models is lowercase:
```
Error: open /var/lib/ollama/.ollama/models/manifests/registry.ollama.ai/library/dolphin-mistral/7b-v2.6-dpo-laser-q6_k: no such file or directory
```

Real model path is `/var/lib/ollama/.ollama/models/manifests/registry.ollama.ai/library/dolphin-mistral/7b-v2.6-dpo-laser-q6_K` - here **q6_K** instead of **q6_k**.

After resolving this (I added symlinks in paths), ollama returns error `Error: unqualified name:` for `ollama list` and `{"error":"unqualified name: "}` for `/api/tags`

Affected version on commit [88cf1544](https://github.com/ollama/ollama/commit/88cf154483cf443e90bf429738f7f37c6b87a36a)

### OS

Linux

### GPU

Nvidia

### CPU

AMD

### Ollama version

0.1.34


Discussion:
@mxyng this issue not fully fixed with #4261. The local created name of the model can also be case-sensitive. E.g. `ollama create MyModel:tag`



Patch:
diff --git a/types/model/name.go b/types/model/name.go
index 6d2a187bc85..b79374c3b73 100644
--- a/types/model/name.go
+++ b/types/model/name.go
@@ -290,12 +290,14 @@ func (n Name) Filepath() string {
 	if !n.IsFullyQualified() {
 		panic("illegal attempt to get filepath of invalid name")
 	}
-	return strings.ToLower(filepath.Join(
-		n.Host,
-		n.Namespace,
-		n.Model,
+	return filepath.Join(
+		strings.ToLower(filepath.Join(
+			n.Host,
+			n.Namespace,
+			n.Model,
+		)),
 		n.Tag,
-	))
+	)
 }
 
 // LogValue returns a slog.Value that represents the name as a string.


Test patch:
diff --git a/types/model/name_test.go b/types/model/name_test.go
index 19bc2e2d73d..fb584291ee2 100644
--- a/types/model/name_test.go
+++ b/types/model/name_test.go
@@ -19,6 +19,16 @@ func TestParseNameParts(t *testing.T) {
 		wantFilepath    string
 		wantValidDigest bool
 	}{
+		{
+			in: "registry.ollama.ai/library/dolphin-mistral:7b-v2.6-dpo-laser-q6_K",
+			want: Name{
+				Host:      "registry.ollama.ai",
+				Namespace: "library",
+				Model:     "dolphin-mistral",
+				Tag:       "7b-v2.6-dpo-laser-q6_K",
+			},
+			wantFilepath: filepath.Join("registry.ollama.ai", "library", "dolphin-mistral", "7b-v2.6-dpo-laser-q6_K"),
+		},
 		{
 			in: "scheme://host:port/namespace/model:tag",
 			want: Name{
@@ -266,9 +276,9 @@ func TestFilepathAllocs(t *testing.T) {
 	allocs := testing.AllocsPerRun(1000, func() {
 		n.Filepath()
 	})
-	allowedAllocs := 2.0
+	var allowedAllocs float64 = 3
 	if runtime.GOOS == "windows" {
-		allowedAllocs = 4
+		allowedAllocs = 5
 	}
 	if allocs > allowedAllocs {
 		t.Errorf("allocs = %v; allowed %v", allocs, allowedAllocs)
Repository: gokcehan/lf (Go)

Issue:
directories no longer bolded
```
~ $ lf -version 
34.r5.g7797ad6 
```

after updating today the only directories that are bolded are the ones with 777 permissions, where as previously all were bolded. presumably this is caused by one of the commits from feb 9?


Discussion:
Most likely #1896. Now that you mention it, I think there's a bug in which leading zeros in escape sequences aren't handled properly, I will try and create a fix for it.



Patch:
diff --git a/colors.go b/colors.go
index 69c5bb14..54e5b21b 100644
--- a/colors.go
+++ b/colors.go
@@ -103,8 +103,8 @@ func applyAnsiCodes(s string, st tcell.Style) tcell.Style {
 	//    Probably because this is used for previewers too
 	tokslen := len(toks)
 	for i := 0; i < tokslen; i++ {
-		switch toks[i] {
-		case "", "0":
+		switch strings.TrimLeft(toks[i], "0") {
+		case "":
 			st = tcell.StyleDefault
 		case "1":
 			st = st.Bold(true)


Test patch:
diff --git a/colors_test.go b/colors_test.go
index e7e62e17..8085ce13 100644
--- a/colors_test.go
+++ b/colors_test.go
@@ -53,6 +53,9 @@ func TestApplyAnsiCodes(t *testing.T) {
 		{"1;31", none, none.Foreground(tcell.ColorMaroon).Bold(true)},
 		{"1;31", none.Foreground(tcell.ColorGreen), none.Foreground(tcell.ColorMaroon).Bold(true)},
 
+		{"01;31", none, none.Foreground(tcell.ColorMaroon).Bold(true)},
+		{"01;31", none.Foreground(tcell.ColorGreen), none.Foreground(tcell.ColorMaroon).Bold(true)},
+
 		{"38;5;0", none, none.Foreground(tcell.ColorBlack)},
 		{"38;5;1", none, none.Foreground(tcell.ColorMaroon)},
 		{"38;5;8", none, none.Foreground(tcell.ColorGray)},
Repository: istio/istio (Go)

Issue:
Validation is rejecting connectionPool.tcp.IdleTimeout=0s
### Is this the right place to submit this?

- [x] This is not a security vulnerability or a crashing bug
- [x] This is not a question about how to use Istio

### Bug Description

Currently the validation webhook is rejecting DR that have the are setting the idletimeout=0s for connectionPool.

For example, the following configuration would end up rejected although it is valid:
```
apiVersion: networking.istio.io/v1
kind: DestinationRule
metadata:
  name: dr-mykind
spec:
  exportTo:
  - .
  host: example.com
  trafficPolicy:
    connectionPool:
      tcp:
        idleTimeout: 0s
    portLevelSettings:
```

In our doc we mention:

> The idle timeout for TCP connections. The idle timeout is defined as the period in which there are no bytes sent or received on either the upstream or downstream connection. If not set, the default idle timeout is 1 hour. **If set to 0s, the timeout will be disabled.** ...



### Version

```Text
-
```

### Additional Information

_No response_


Discussion:

Patch:
diff --git a/pkg/config/validation/validation.go b/pkg/config/validation/validation.go
index fa587a72fc54..a1c9f807e821 100644
--- a/pkg/config/validation/validation.go
+++ b/pkg/config/validation/validation.go
@@ -1109,7 +1109,10 @@ func validateConnectionPool(settings *networking.ConnectionPoolSettings) (errs e
 			errs = appendErrors(errs, agent.ValidateDuration(tcp.MaxConnectionDuration))
 		}
 		if tcp.IdleTimeout != nil {
-			errs = appendErrors(errs, agent.ValidateDuration(tcp.IdleTimeout))
+			// Skip validation if the value is 0s, as it indicates that the timeout is disabled entirely.
+			if tcp.IdleTimeout.AsDuration().Milliseconds() != 0 {
+				errs = appendErrors(errs, agent.ValidateDuration(tcp.IdleTimeout))
+			}
 		}
 		if ka := tcp.TcpKeepalive; ka != nil {
 			if ka.Time != nil {
diff --git a/releasenotes/notes/55409.yaml b/releasenotes/notes/55409.yaml
new file mode 100644
index 000000000000..3cce60fda257
--- /dev/null
+++ b/releasenotes/notes/55409.yaml
@@ -0,0 +1,8 @@
+apiVersion: release-notes/v2
+kind: bug-fix
+area: traffic-management
+issue:
+  - 55409
+releaseNotes:
+- |
+  **Fixed** validation webhook rejecting an otherwise valid connectionPool.tcp.IdleTimeout=0s


Test patch:
diff --git a/pkg/config/validation/validation_test.go b/pkg/config/validation/validation_test.go
index 378ec261705b..02d465ad715c 100644
--- a/pkg/config/validation/validation_test.go
+++ b/pkg/config/validation/validation_test.go
@@ -3174,6 +3174,13 @@ func TestValidateConnectionPool(t *testing.T) {
 			valid: false,
 		},
 
+		{
+			name: "valid connection pool, tcp timeout disabled", in: &networking.ConnectionPoolSettings{
+				Tcp: &networking.ConnectionPoolSettings_TCPSettings{IdleTimeout: &durationpb.Duration{Seconds: 0}},
+			},
+			valid: true,
+		},
+
 		{
 			name: "invalid connection pool, bad max concurrent streams", in: &networking.ConnectionPoolSettings{
 				Http: &networking.ConnectionPoolSettings_HTTPSettings{MaxConcurrentStreams: -1},
Repository: jaegertracing/jaeger (Go)

Issue:
[Bug]: The CHILD_OF span reference is moved to the second place incorrectly
### What happened?

When the first span reference is typed as 'CHILD_OF' and other references are 'FOLLOWS_FROM' with the same trace id, the first 'CHILD_OF' span referenced is swapped to the second place.

### Steps to reproduce

Create a span with 2 references. The first is a 'CHILD_OF' reference. The second is a 'FOLLOWS_FROM' reference. Both of them point to spans of the same trace id with the referencing one.

### Expected behavior

The order should be unchanged.

### Relevant log output

_No response_

### Screenshot

_No response_

### Additional context

_No response_

### Jaeger backend version

_No response_

### SDK

_No response_

### Pipeline

_No response_

### Stogage backend

_No response_

### Operating system

_No response_

### Deployment model

_No response_

### Deployment configs

_No response_


Discussion:
Could you explain what made you investigate, what user-facing problem this was causing?



Patch:
diff --git a/model/adjuster/parent_reference.go b/model/adjuster/parent_reference.go
index 578518db213..272e98e2909 100644
--- a/model/adjuster/parent_reference.go
+++ b/model/adjuster/parent_reference.go
@@ -26,7 +26,7 @@ func ParentReference() Adjuster {
 		for _, span := range trace.Spans {
 			firstChildOfRef := -1
 			firstOtherRef := -1
-			for i := 1; i < len(span.References); i++ {
+			for i := 0; i < len(span.References); i++ {
 				if span.References[i].TraceID == span.TraceID {
 					if span.References[i].RefType == model.SpanRefType_CHILD_OF {
 						firstChildOfRef = i
@@ -40,7 +40,7 @@ func ParentReference() Adjuster {
 			if swap == -1 {
 				swap = firstOtherRef
 			}
-			if swap != -1 {
+			if swap != 0 && swap != -1 {
 				span.References[swap], span.References[0] = span.References[0], span.References[swap]
 			}
 		}


Test patch:
diff --git a/model/adjuster/parent_reference_test.go b/model/adjuster/parent_reference_test.go
index 8c26fe92a4a..bf53ed2765d 100644
--- a/model/adjuster/parent_reference_test.go
+++ b/model/adjuster/parent_reference_test.go
@@ -56,6 +56,11 @@ func TestParentReference(t *testing.T) {
 			incoming: []model.SpanRef{childOf(b)},
 			expected: []model.SpanRef{childOf(b)},
 		},
+		{
+			name:     "local, local follows - keep order",
+			incoming: []model.SpanRef{childOf(a), followsFrom(a)},
+			expected: []model.SpanRef{childOf(a), followsFrom(a)},
+		},
 		{
 			name:     "local and remote child in order",
 			incoming: []model.SpanRef{childOf(a), childOf(b)},
Repository: google/go-github (Go)

Issue:
The `AppID` field of `ListCheckSuiteOptions` is an `int`
In this library a GitHub app ID is usually represented as an `int64` but in the `ListCheckSuiteOptions` this is currently an `int`.


Discussion:
Thank you, @stevehipwell! Do you want to address this one?
@gmlewis yes, I'll add a PR to correct this.



Patch:
diff --git a/github/checks.go b/github/checks.go
index 2f0f65bf92a..6f9c4191cda 100644
--- a/github/checks.go
+++ b/github/checks.go
@@ -345,7 +345,7 @@ func (s *ChecksService) ReRequestCheckRun(ctx context.Context, owner, repo strin
 // ListCheckSuiteOptions represents parameters to list check suites.
 type ListCheckSuiteOptions struct {
 	CheckName *string `url:"check_name,omitempty"` // Filters checks suites by the name of the check run.
-	AppID     *int    `url:"app_id,omitempty"`     // Filters check suites by GitHub App id.
+	AppID     *int64  `url:"app_id,omitempty"`     // Filters check suites by GitHub App id.
 
 	ListOptions
 }
diff --git a/github/github-accessors.go b/github/github-accessors.go
index ad06c78c9fa..6526a7c6675 100644
--- a/github/github-accessors.go
+++ b/github/github-accessors.go
@@ -13319,7 +13319,7 @@ func (l *ListCheckRunsResults) GetTotal() int {
 }
 
 // GetAppID returns the AppID field if it's non-nil, zero value otherwise.
-func (l *ListCheckSuiteOptions) GetAppID() int {
+func (l *ListCheckSuiteOptions) GetAppID() int64 {
 	if l == nil || l.AppID == nil {
 		return 0
 	}


Test patch:
diff --git a/github/checks_test.go b/github/checks_test.go
index fac30ec2871..b451caab588 100644
--- a/github/checks_test.go
+++ b/github/checks_test.go
@@ -472,7 +472,7 @@ func TestChecksService_ListCheckSuiteForRef(t *testing.T) {
 
 	opt := &ListCheckSuiteOptions{
 		CheckName:   Ptr("testing"),
-		AppID:       Ptr(2),
+		AppID:       Ptr(int64(2)),
 		ListOptions: ListOptions{Page: 1},
 	}
 	ctx := context.Background()
diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go
index 0abd03fe319..b0201a7302e 100644
--- a/github/github-accessors_test.go
+++ b/github/github-accessors_test.go
@@ -17269,7 +17269,7 @@ func TestListCheckRunsResults_GetTotal(tt *testing.T) {
 
 func TestListCheckSuiteOptions_GetAppID(tt *testing.T) {
 	tt.Parallel()
-	var zeroValue int
+	var zeroValue int64
 	l := &ListCheckSuiteOptions{AppID: &zeroValue}
 	l.GetAppID()
 	l = &ListCheckSuiteOptions{}
Repository: xanzy/go-gitlab (Go)

Issue:
Repositories API Compare call is missing WebURL
Calling `Repositories.Compare` returns a `Compare` object. Per the GitLab docs, the response includes a `web_url` field, however that is not in the Go type.

This should just need the field after here: https://github.com/xanzy/go-gitlab/blob/87336053bb9d01ec3fdb043114af22ac31667875/repositories.go#L211


Discussion:

Patch:
diff --git a/repositories.go b/repositories.go
index dde876174..3c59f9abc 100644
--- a/repositories.go
+++ b/repositories.go
@@ -209,6 +209,7 @@ type Compare struct {
 	Diffs          []*Diff   `json:"diffs"`
 	CompareTimeout bool      `json:"compare_timeout"`
 	CompareSameRef bool      `json:"compare_same_ref"`
+	WebURL         string    `json:"web_url"`
 }
 
 func (c Compare) String() string {


Test patch:
diff --git a/repositories_test.go b/repositories_test.go
index 4610bf3e8..9130defcb 100644
--- a/repositories_test.go
+++ b/repositories_test.go
@@ -281,6 +281,7 @@ func TestRepositoriesService_Compare(t *testing.T) {
 		}},
 		CompareTimeout: false,
 		CompareSameRef: false,
+		WebURL:         "https://gitlab.example.com/thedude/gitlab-foss/-/compare/ae73cb07c9eeaf35924a10f713b364d32b2dd34f...0b4bc9a49b562e85de7cc9e834518ea6828729b9",
 	}
 
 	c, resp, err := client.Repositories.Compare("12d65c8dd2b2676fa3ac47d955accc085a37a9c1", opt, nil)
Repository: go-resty/resty (Go)

Issue:
`jitterBackoff` Panic When max = 1 ns
Setting max timeout of 1 ns (`time.Duration(1) * time.Nanosecond`) can cause the `jitterBackoff` function panic.
```
panic: invalid argument to Int63n [recovered]
        panic: invalid argument to Int63n

goroutine 37 [running]:
testing.tRunner.func1.2({0x1040b2f80, 0x10433ee98})
        /opt/homebrew/Cellar/go/1.20.1/libexec/src/testing/testing.go:1526 +0x1c8
testing.tRunner.func1()
        /opt/homebrew/Cellar/go/1.20.1/libexec/src/testing/testing.go:1529 +0x364
panic({0x1040b2f80, 0x10433ee98})
        /opt/homebrew/Cellar/go/1.20.1/libexec/src/runtime/panic.go:884 +0x1f4
math/rand.(*Rand).Int63n(0xe?, 0x140002615a8?)
        /opt/homebrew/Cellar/go/1.20.1/libexec/src/math/rand/rand.go:121 +0xe8
github.com/go-resty/resty/v2.randDuration(0x0)
        /Users/myusername/dev/resty/retry.go:215 +0xd8
github.com/go-resty/resty/v2.jitterBackoff(0xb2d05e00, 0x1, 0x6?)
        /Users/myusername/dev/resty/retry.go:198 +0xb0
github.com/go-resty/resty/v2.sleepDuration(0x14000379540?, 0xb2d05e00, 0x0?, 0x102f1c044?)
        /Users/myusername/dev/resty/retry.go:178 +0xa8
github.com/go-resty/resty/v2.Backoff(0x14000261870, {0x14000261848, 0x5, 0x1400078d1c8?})
        /Users/myusername/dev/resty/retry.go:139 +0x288
...
```


Discussion:
@zliang-akamai Thanks for reaching out. I will check it out. In the meantime, do you mind providing a small test case? so that I could use that to validate at my end.



Patch:
diff --git a/retry.go b/retry.go
index f8c76659..e0b856ae 100644
--- a/retry.go
+++ b/retry.go
@@ -209,6 +209,9 @@ func jitterBackoff(min, max time.Duration, attempt int) time.Duration {
 
 	temp := math.Min(capLevel, base*math.Exp2(float64(attempt)))
 	ri := time.Duration(temp / 2)
+	if ri == 0 {
+		ri = time.Nanosecond
+	}
 	result := randDuration(ri)
 
 	if result < min {


Test patch:
diff --git a/retry_test.go b/retry_test.go
index d979fbfe..d04cae4f 100644
--- a/retry_test.go
+++ b/retry_test.go
@@ -295,6 +295,20 @@ func TestClientRetryWaitMaxInfinite(t *testing.T) {
 	}
 }
 
+func TestClientRetryWaitMaxMinimum(t *testing.T) {
+	ts := createGetServer(t)
+	defer ts.Close()
+
+	const retryMaxWaitTime = time.Nanosecond // minimal duration value
+
+	c := dc().
+		SetRetryCount(1).
+		SetRetryMaxWaitTime(retryMaxWaitTime).
+		AddRetryCondition(func(*Response, error) bool { return true })
+	_, err := c.R().Get(ts.URL + "/set-retrywaittime-test")
+	assertError(t, err)
+}
+
 func TestClientRetryWaitCallbackError(t *testing.T) {
 	ts := createGetServer(t)
 	defer ts.Close()