prom-client#Gauge TypeScript Examples

constructor() {
    this.faucetRequestCounter = new promClient.Counter({
      name: 'faucet_request_total',
      help: 'Count of faucet requests'
    });
    this.deployRequestCounter = new promClient.Counter({
      name: 'deploy_request_total',
      help: 'Count of deploy requests'
    });
    this.accountKeyGauge = new promClient.Gauge({
      name: 'account_key_total',
      help: 'Count of account key'
    });
    this.accountGauge = new promClient.Gauge({
      name: 'user_account_total',
      help: 'Count of user account'
    });
    this.dailyLoginGauge = new promClient.Gauge({
      name: 'daily_login_days',
      help: 'Number of logins every day'
    });
    this.dailySignupGauge = new promClient.Gauge({
      name: 'daily_signup_days',
      help: 'Number of sign up every day'
    });
  }

private static initRegistry = _.once(() => {
    if (MetricsProvider.registry != null) {
      return MetricsProvider.registry
    }

    const registry = new Registry()
    registry.setDefaultLabels({ country: 'USA' })

    for (const key in keyNameMapping) {
      const metric = keyNameMapping[key]
      const gauge: Gauge<string> = new Gauge({
        name: `covid_${metric}`,
        help: key,
        labelNames: ['country', 'state'],
      })
      registry.registerMetric(gauge)
    }

    return registry
  })

public static getMetrics = async () => {
    const registry = MetricsProvider.registry
    const states = _.get(
      await axios.get('https://corona.lmao.ninja/states'),
      'data',
    )
    _.each(states, (s) => {
      const { state, ...stats } = s
      for (const key in stats as { [key: string]: number }) {
        const metricKey = `covid_${keyNameMapping[key]}`
        const value = _.get(stats, key)
        const gauge = registry.getSingleMetric(metricKey) as Gauge<any>
        if (value != null) {
          gauge.set(
            {
              country: 'USA',
              state,
            },
            value,
          )
        }
      }
    })

    return registry.metrics()
  }

constructor() {
    this.faucetRequestCounter = new promClient.Counter({
      name: 'faucet_request_total',
      help: 'Count of faucet requests'
    });
    this.deployRequestCounter = new promClient.Counter({
      name: 'deploy_request_total',
      help: 'Count of deploy requests'
    });
    this.accountKeyGauge = new promClient.Gauge({
      name: 'account_key_total',
      help: 'Count of account key'
    });
    this.accountGauge = new promClient.Gauge({
      name: 'user_account_total',
      help: 'Count of user account'
    });
    this.dailyLoginGauge = new promClient.Gauge({
      name: 'daily_login_days',
      help: 'Number of logins every day'
    });
    this.dailySignupGauge = new promClient.Gauge({
      name: 'daily_signup_days',
      help: 'Number of sign up every day'
    });
  }

public dailyLoginGauge: Gauge<string>;

stakedALCXUnclaimedUSD = new Gauge({
  name: "fuse_staked_alcx_unclaimed_usd",
  help: "Stores how much protocol controlled ALCX is claimable from staking."
})

stakedALCXAmount = new Gauge({
  name: "fuse_staked_alcx_amount",
  help: "Stores how much protocol controlled ALCX is currently being staked."
})

stakedALCXUnclaimedAmount = new Gauge({
  name: "fuse_staked_alcx_unclaimed_amount",
  help: "Stores how much protocol controlled ALCX is claimable from staking."
})

export function createGaugeMetric<T extends string>(
  config: GaugeConfiguration<T>,
): Gauge<T> {
  const existing = register.getSingleMetric(config.name) as Gauge<T>;
  return existing || new Gauge<T>(config);
}

public accountKeyGauge: Gauge<string>;

public accountGauge: Gauge<string>;

poolAssetsFeesUSD = new Gauge({
  name: "fuse_pool_assets_fees_usd",
  help: "Stores how much of each asset has been taken as fees in each pool.",
  labelNames: ["id", "symbol"] as const
})

public dailySignupGauge: Gauge<string>;

leaderboardUpdate = new Gauge({
  name: "leaderboard_update_seconds",
  help: "Leaderboard update time",
  labelNames: ["language", "mode", "mode2", "step"],
})

private registerMetrics(registry: Registry): void {
        this.metrics = {};

        if (this.collectFrom.psql_connection !== false) {
            this.metrics.psql_connection = new Gauge({
                name: 'eos_contract_api_sql_live',
                registers: [registry],
                labelNames: ['process', 'hostname'],
                help: 'Indicates if the sql connection is alive, 1 = Alive, 0 = Dead'
            });
        }

        if (this.collectFrom.psql_pool !== false) {
            this.metrics.psql_pool_clients_total_count = new Gauge({
                name: 'eos_contract_api_pool_clients_count',
                registers: [registry],
                labelNames: ['process', 'hostname'],
                help: 'Indicates how many client connections has spawn'
            });
            this.metrics.psql_pool_clients_waiting_count = new Gauge({
                name: 'eos_contract_api_waiting_pool_clients_count',
                registers: [registry],
                labelNames: ['process', 'hostname'],
                help: 'Indicates how many sql client connections are waiting'
            });
            this.metrics.psql_pool_clients_idle_count = new Gauge({
                name: 'eos_contract_api_idle_pool_clients_count',
                registers: [registry],
                labelNames: ['process', 'hostname'],
                help: 'Indicates how many sql client connections are idle'
            });
        }

        if (this.collectFrom.readers !== false) {
            this.metrics.readers_blocks_behind_count = new Gauge({
                name: 'eos_contract_api_readers_blocks_behind_count',
                registers: [registry],
                labelNames: ['process', 'hostname', 'filler_name'],
                help: 'Indicates how many blocks is the filler behind the chain'
            });
            this.metrics.readers_time_behind_chain_sec = new Gauge({
                name: 'eos_contract_api_readers_time_behind_chain_sec',
                registers: [registry],
                labelNames: ['process', 'hostname', 'filler_name'],
                help: 'Indicates how much time in seconds, is the filler behind the chain'
            });
        }

        if (this.collectFrom.redis_connection !== false) {
            this.metrics.redis_connection = new Gauge({
                name: 'eos_contract_api_redis_live',
                registers: [registry],
                labelNames: ['process', 'hostname'],
                help: 'Indicates if the redis connection is alive, 1 = Alive, 0 = Dead'
            });
        }

    }

private lastBlock = new Gauge({
        name: 'sqd_processor_last_block',
        help: 'Last processed block',
        registers: [this.registry],
        aggregator: 'max'
    })

private chainHeight = new Gauge({
        name: 'sqd_processor_chain_height',
        help: 'Chain height of the data source',
        registers: [this.registry],
        aggregator: 'max'
    })

private mappingSpeed = new Gauge({
        name: 'sqd_processor_mapping_blocks_per_second',
        help: 'Mapping performance',
        registers: [this.registry],
        aggregator: 'average'
    })

private ingestSpeed = new Gauge({
        name: 'sqd_processor_ingest_blocks_per_second',
        help: 'Data fetching speed',
        registers: [this.registry],
        aggregator: 'average'
    })

private syncETA = new Gauge({
        name: 'sqd_processor_sync_eta_seconds',
        help: 'Estimated time until all required blocks will be processed or until chain height will be reached',
        registers: [this.registry]
    })

private syncRatio = new Gauge({
        name: 'sqd_processor_sync_ratio',
        help: 'Percentage of processed blocks',
        registers: [this.registry],
        aggregator: 'max'
    })

poolAssetsInterestRate = new Gauge({
  name: "fuse_pool_assets_interest_rate",
  help: "Stores the interest rates of each asset in each pool.",
  // Side: borrow, supply
  labelNames: ["id", "symbol", "side"] as const
})

public accountKeyGauge: Gauge<string>;

public accountGauge: Gauge<string>;

public dailyLoginGauge: Gauge<string>;

public dailySignupGauge: Gauge<string>;

public static gaugeGatewayPing = new Gauge({
    name: 'fsb_gateway_ping',
    help: 'Shows the current gateway ping. Updated every 10 seconds.'
  })

public static gaugeGuildCacheSize = new Gauge({
    name: 'fsb_caches_guilds_size',
    help: 'Amount of guilds currently cached on this worker. Updated every 10 seconds.'
  })

public static gaugeUserCacheSize = new Gauge({
    name: 'fsb_caches_users_size',
    help: 'Amount of users currently cached on this worker. Updated every 10 seconds.'
  })