Feat/agreement score (#346)

* feat: agreement score * feat: add log * fix: traceId
subquery · Nov 19, 2024 · 168d369 · 168d369
1 parent c93c975
commit 168d369
Show file tree

Hide file tree

Showing 4 changed files with 56 additions and 18 deletions.
diff --git a/packages/network-support/src/fetch.ts b/packages/network-support/src/fetch.ts
@@ -235,6 +235,7 @@ export function createFetch(
               scoreType,
             });
             const extraLog = {
+              traceId,
               requestId,
               retry: retries,
               error: errorMsg,

diff --git a/packages/network-support/src/orderManager.ts b/packages/network-support/src/orderManager.ts
@@ -505,11 +505,11 @@ export class OrderManager {
     return plan;
   }
 
-  private async selectRunner(orders: Order[], type: OrderType): Promise<Order | undefined> {
+  private async selectRunner(orders: Order[], orderType: OrderType): Promise<Order | undefined> {
     if (!orders.length) return;
     const scores = await Promise.all(
       orders.map((o) =>
-        this.scoreManager.getAdjustedScore(o.indexer, o.metadata?.proxyVersion, type)
+        this.scoreManager.getAdjustedScore(o.indexer, o.metadata?.proxyVersion, orderType)
       )
     );
     const random = Math.random() * scores.reduce((a, b) => a + b.score, 0);
@@ -529,6 +529,7 @@ export class OrderManager {
           indexer: orders[i].indexer,
           score: scores[i].score,
           detail: scores[i].scoreDetail,
+          orderType,
         });
         return orders[i];
       }
@@ -568,11 +569,19 @@ export class OrderManager {
     this.agreements[index].token = token;
   }
 
-  async getScore(runner: string) {
-    const plans = this._plans || [];
+  async getScore(runner: string, orderType?: OrderType) {
+    orderType = orderType || OrderType.flexPlan;
+
+    let plans = this._plans;
+    if (orderType === OrderType.agreement) {
+      plans = this._agreements;
+    }
+    plans = plans || [];
+
     const plan = plans.find((p) => p.indexer === runner);
     const proxyVersion = plan?.metadata?.proxyVersion || '';
-    return this.scoreManager.getAdjustedScore(runner, proxyVersion);
+
+    return this.scoreManager.getAdjustedScore(runner, proxyVersion, orderType);
   }
 
   async updateScore(runner: string, errorType: ScoreType, httpVersion?: number, extraLog?: any) {

diff --git a/packages/network-support/src/scoreManager.ts b/packages/network-support/src/scoreManager.ts
@@ -92,19 +92,19 @@ export class ScoreManager {
   async getAdjustedScore(
     runner: string,
     proxyVersion?: string,
-    type?: OrderType
+    orderType?: OrderType
   ): Promise<ScoreWithDetail> {
     proxyVersion = proxyVersion || '';
-    type = type || OrderType.flexPlan;
+    orderType = orderType || OrderType.flexPlan;
     const score = await this.getScore(runner);
     const base = this.getAvailabilityScore(score);
     const http2 = this.getHttpVersionWeight(score);
     const manual = await this.getManualScoreWeight(runner, this.projectId);
     const multiple = this.getMultipleAuthScoreWeight(proxyVersion);
     const block = await getBlockScoreWeight(this.scoreStore, runner, this.projectId);
-    const latency = await getLatencyScoreWeight(this.scoreStore, runner, this.projectId);
+    const latency = await getLatencyScoreWeight(this.scoreStore, runner, this.projectId, orderType);
     const price = await this.getPriceScoreWeight(runner);
-    const ratelimitInfo = await this.getRatelimitWeightInfo(runner, type);
+    const ratelimitInfo = await this.getRatelimitWeightInfo(runner, orderType);
     const ratelimitWeight = ratelimitInfo.weight;
 
     this.logger?.debug(

diff --git a/packages/network-support/src/utils/score.ts b/packages/network-support/src/utils/score.ts
@@ -3,16 +3,25 @@
 
 import BigNumber from 'bignumber.js';
 import { IStore } from './store';
+import { OrderType } from '../types';
 
 const BLOCK_WEIGHT_OUTPUT_RANGE: [number, number] = [0.2, 1];
-const LATENCY_WEIGHT_THRESHOLD: [threshold: number, weight: number][] = [
+const PLAN_LATENCY_WEIGHT_THRESHOLD: [threshold: number, weight: number][] = [
   [2_000, 0.2], // >= 2000ms: 0.2
   [1_000, 0.5], //  [1000ms, 2000ms): 0.5
   [500, 1], //  [500ms, 1000ms): 1
   [300, 3], //  [300ms, 500ms): 3
   [0, 6], //  [0ms, 300ms): 6
 ];
 
+const AGREEMENT_LATENCY_WEIGHT_THRESHOLD: [threshold: number, weight: number][] = [
+  [2_000, 0.2], // >= 2000ms: 0.2
+  [1_000, 0.5], //  [1000ms, 2000ms): 0.5
+  [500, 1], //  [500ms, 1000ms): 1
+  [300, 6], //  [300ms, 500ms): 6
+  [0, 12], //  [0ms, 300ms): 12
+];
+
 export enum CurveType {
   LINEAR = 1,
   QUADRATIC = 2,
@@ -83,23 +92,39 @@ export async function updateLatencyScoreWeight(
   }
 
   for (let i = 0; i < indexerLantency.length; i++) {
-    let weight = 1;
-    for (const [threshold, wt] of LATENCY_WEIGHT_THRESHOLD) {
+    let planWeight = 1;
+    for (const [threshold, wt] of PLAN_LATENCY_WEIGHT_THRESHOLD) {
       if (medians[i] && medians[i] >= threshold) {
-        weight = wt;
+        planWeight = wt;
         break;
       }
     }
-    await scoreStore.set(`${key}:${indexerLantency[i].indexer}_${deploymentId}`, weight);
+
+    let agreementWeight = 1;
+    for (const [threshold, wt] of AGREEMENT_LATENCY_WEIGHT_THRESHOLD) {
+      if (medians[i] && medians[i] >= threshold) {
+        agreementWeight = wt;
+        break;
+      }
+    }
+    await scoreStore.set(
+      `${key}:${OrderType.flexPlan}:${indexerLantency[i].indexer}_${deploymentId}`,
+      planWeight
+    );
+    await scoreStore.set(
+      `${key}:${OrderType.agreement}:${indexerLantency[i].indexer}_${deploymentId}`,
+      agreementWeight
+    );
     logger?.debug(
-      `updateLatencyScoreWeight: ${indexerLantency[i].indexer} ${deploymentId}(min:${min}, max:${max}) ${medians[i]} => ${weight}`
+      `updateLatencyScoreWeight: ${indexerLantency[i].indexer} ${deploymentId}(min:${min}, max:${max}) ${medians[i]} => plan:${planWeight}, agreement:${agreementWeight}`
     );
     logger?.info({
       type: 'updateScore',
       target: 'latencyWeight',
       deploymentId,
       indexer: indexerLantency[i].indexer,
-      to: weight,
+      toPlan: planWeight,
+      toAgreement: agreementWeight,
     });
   }
 }
@@ -117,9 +142,12 @@ export async function getBlockScoreWeight(
 export async function getLatencyScoreWeight(
   scoreStore: IStore,
   runner: string,
-  deploymentId: string
+  deploymentId: string,
+  orderType?: OrderType
 ) {
-  const key = `${getLatencyScoreKey()}:${runner}_${deploymentId}`;
+  orderType = orderType || OrderType.flexPlan;
+  const orderKey = orderType as string;
+  const key = `${getLatencyScoreKey()}:${orderKey}:${runner}_${deploymentId}`;
   const latencyWeight = await scoreStore.get<number>(key);
   return latencyWeight || 1;
 }