Tutorial do NerdGraph: lidar com limites de simultaneidade

import got from 'got';
import async from 'async';

const API_KEY = '<key>' //GraphQL User Key
const MAX_CONCURRENCY = 25; //Maximum amount of requests in queue at a given time

const GRAPH_API = 'https://api.newrelic.com/graphql';
const HEADERS = { 'Content-Type': 'application/json', 'Api-Key': API_KEY };


async function main() {
  let accounts = await getAccounts(); //All accounts to run a query against
  var allResults = [];

  //Queue initialization
  const q = async.queue(async (task, cb) => {
    let result = await makeRequest(task.acct)
    allResults.push({'transactionCount': result[0].count, 'account': task.acct.id});
    cb();
  }, MAX_CONCURRENCY);

  //Push requests on to the queue (one for each account)
  accounts.forEach(acct => {
    q.push({acct: acct});
  });

  await q.drain(); //Drain event listener when all tasks are complete

  console.log(allResults);
}

async function makeRequest(acct) {
  let nrql = `SELECT count(*) FROM Transaction`;
  let gql = `{
      actor {
        account(id: ${acct.id}) {
          nrql(query: "${nrql}", timeout: 90) {
            results
          }
        }
      }
    }`;

  let opts = {
    url: GRAPH_API,
    headers: HEADERS,
    json: {'query': gql, 'variables': {}}
  };

  let response = await got.post(opts).json();
  if (!response.errors) {
    return response.data.actor.account.nrql.results;
  } else {
    console.log('Query Error');
    console.log(response.errors);
  }
}

async function getAccounts() {
  var q = `{
            actor {
              accounts {
                id
                name
              }
            }
          }`

  var opts = {
    url: GRAPH_API,
    headers: HEADERS,
    json: {'query': q, 'variables': {}}
  }

  let resp = await got.post(opts).json();
  return resp.data.actor.accounts;
}


main();

import aiohttp
import asyncio

API_KEY = '<key>'
MAX_CONCURRENCY = 25
GRAPHQL_API = 'https://api.newrelic.com/graphql'
HEADERS = {'Content-Type': 'application/json', 'Api-Key': API_KEY}


async def main():
    #All accounts to run a query against
    accounts = await get_accounts()

    # Semaphore for controlling concurrency
    limit = asyncio.Semaphore(MAX_CONCURRENCY)

    #Add all accounts to run a query against
    tasks = [send_request(acct, limit) for acct in accounts]

    #Schedule all tasks to run concurrently
    allResults = await asyncio.gather(*tasks)

    print(allResults)


async def send_request(acct, limit):
    nrql = "SELECT count(*) FROM Transaction"
    gql = f'''
    {{
      actor {{
        account(id: {acct['id']}) {{
          nrql(query: "{nrql}", timeout: 90) {{
            results
          }}
        }}
      }}
    }}
    '''

    async with limit:
        try:
            async with aiohttp.ClientSession() as session:
                async with session.post(GRAPHQL_API, json={"query": gql, "variables":{}}, headers=HEADERS) as response:
                    result = await response.json()
                    return {'transactionCount': result['data']['actor']['account']['nrql']['results'][0]['count'], 'account': acct['id']}
        except Exception as error:
            print("Query Error")
            raise error


async def get_accounts():
    gql = """
    {
      actor {
        accounts {
          id
          name
        }
       }
     }
    """

    async with aiohttp.ClientSession() as session:
        async with session.post(GRAPHQL_API, json={"query": gql, "variables":{}}, headers=HEADERS) as response:
            result = await response.json()
            return result['data']['actor']['accounts']


if __name__ == '__main__':
    asyncio.run(main()) #Run event loop