feat(github-graphql): introduce hierarchical fallback for GraphQL rate limit

Implement a layered fallback mechanism for GraphQL rate limiting:

1. Dynamic rate limit from provider (getRateRemaining)
2. Per-client override (WithFallbackRateLimit)
3. Config override (GRAPHQL_RATE_LIMIT)
4. Default fallback (1000)

Also moved GitHub-specific fallback (5000) via WithFallbackRateLimit
to the Graphql client.

Author: Ke-vin-S

backend/helpers/pluginhelper/api/graphql_async_client.go

@@ -24,12 +24,16 @@ import (
 	"github.com/apache/incubator-devlake/core/log"
 	"github.com/apache/incubator-devlake/core/plugin"
 	"github.com/apache/incubator-devlake/core/utils"
+	"strconv"
 	"sync"
 	"time"
 
 	"github.com/merico-ai/graphql"
 )
 
+// GraphqlClientOption is a function that configures a GraphqlAsyncClient
+type GraphqlClientOption func(*GraphqlAsyncClient)
+
 // GraphqlAsyncClient send graphql one by one
 type GraphqlAsyncClient struct {
 	ctx       context.Context
@@ -47,34 +51,48 @@ type GraphqlAsyncClient struct {
 	getRateCost      func(q interface{}) int
 }
 
-const defaultRateLimit = 5000
+// defaultRateLimitConst is the generic fallback rate limit for GraphQL requests.
+// It is used as the initial remaining quota when dynamic rate limit
+// information is unavailable from the provider.
+const defaultRateLimitConst = 1000
 
 // CreateAsyncGraphqlClient creates a new GraphqlAsyncClient
 func CreateAsyncGraphqlClient(
 	taskCtx plugin.TaskContext,
 	graphqlClient *graphql.Client,
 	logger log.Logger,
 	getRateRemaining func(context.Context, *graphql.Client, log.Logger) (rateRemaining int, resetAt *time.Time, err errors.Error),
+	opts ...GraphqlClientOption,
 ) (*GraphqlAsyncClient, errors.Error) {
 	ctxWithCancel, cancel := context.WithCancel(taskCtx.GetContext())
+
+	rateLimit := resolveRateLimit(taskCtx, logger)
+
 	graphqlAsyncClient := &GraphqlAsyncClient{
 		ctx:              ctxWithCancel,
 		cancel:           cancel,
 		client:           graphqlClient,
 		logger:           logger,
 		rateExhaustCond:  sync.NewCond(&sync.Mutex{}),
-		rateRemaining:    0,
+		rateRemaining:    rateLimit,
 		getRateRemaining: getRateRemaining,
 	}
 
+	// apply options
+	for _, opt := range opts {
+		opt(graphqlAsyncClient)
+	}
+
 	if getRateRemaining != nil {
 		rateRemaining, resetAt, err := getRateRemaining(taskCtx.GetContext(), graphqlClient, logger)
 		if err != nil {
 			graphqlAsyncClient.logger.Warn(err, "failed to fetch initial graphql rate limit, fallback to default")
-			graphqlAsyncClient.updateRateRemaining(defaultRateLimit, nil)
+			graphqlAsyncClient.updateRateRemaining(graphqlAsyncClient.rateRemaining, nil)
 		} else {
 			graphqlAsyncClient.updateRateRemaining(rateRemaining, resetAt)
 		}
+	} else {
+		graphqlAsyncClient.updateRateRemaining(graphqlAsyncClient.rateRemaining, nil)
 	}
 
 	// load retry/timeout from configuration
@@ -119,6 +137,10 @@ func (apiClient *GraphqlAsyncClient) updateRateRemaining(rateRemaining int, rese
 		apiClient.rateExhaustCond.Signal()
 	}
 	go func() {
+		if apiClient.getRateRemaining == nil {
+			return
+		}
+
 		nextDuring := 3 * time.Minute
 		if resetAt != nil && resetAt.After(time.Now()) {
 			nextDuring = time.Until(*resetAt)
@@ -224,3 +246,29 @@ func (apiClient *GraphqlAsyncClient) Wait() {
 func (apiClient *GraphqlAsyncClient) Release() {
 	apiClient.cancel()
 }
+
+// WithFallbackRateLimit sets the initial/fallback rate limit used when
+// rate limit information cannot be fetched dynamically.
+// This value may be overridden later by getRateRemaining.
+func WithFallbackRateLimit(limit int) GraphqlClientOption {
+	return func(c *GraphqlAsyncClient) {
+		if limit > 0 {
+			c.rateRemaining = limit
+		}
+	}
+}
+
+// resolveRateLimit determines the rate limit for GraphQL requests using task configuration -> else default constant.
+func resolveRateLimit(taskCtx plugin.TaskContext, logger log.Logger) int {
+	rateLimit := defaultRateLimitConst
+
+	if v := taskCtx.GetConfig("GRAPHQL_RATE_LIMIT"); v != "" {
+		if parsed, err := strconv.Atoi(v); err == nil {
+			rateLimit = parsed
+		} else {
+			logger.Warn(err, "invalid GRAPHQL_RATE_LIMIT, using default")
+		}
+	}
+
+	return rateLimit
+}

backend/plugins/github_graphql/impl/impl.go

@@ -189,8 +189,8 @@ func (p GithubGraphql) PrepareTaskData(taskCtx plugin.TaskContext, options map[s
 				return 0, nil, errors.Default.Wrap(dataErrors[0], `query rate limit fail`)
 			}
 			if query.RateLimit == nil {
-				logger.Info(`github graphql rate limit are disabled, fallback to 5000req/hour`)
-				return 5000, nil, nil
+				logger.Info(`github graphql rate limit unavailable, using fallback rate limit`)
+				return 0, nil, errors.Default.New("rate limit unavailable")
 			}
 			logger.Info(`github graphql init success with remaining %d/%d and will reset at %s`,
 				query.RateLimit.Remaining, query.RateLimit.Limit, query.RateLimit.ResetAt)

backend/plugins/github_graphql/tasks/graphql_client.go

@@ -65,5 +65,7 @@ func CreateGraphqlClient(
 		gqlClient,
 		taskCtx.GetLogger(),
 		getRateRemaining,
+		// GitHub GraphQL default fallback aligns with GitHub's standard rate limit (~5000)
+		helper.WithFallbackRateLimit(5000),
 	)
 }