Encontrar e gerar relatórios

Depois de identificar ou criar um relatório que satisfaça suas necessidades, é hora de gerar a saída. A saída do relatório é armazenada em arquivos de relatório, que podem ser recuperados e manipulados de forma programática. Um arquivo de relatório é gerado como resultado da geração de um relatório.

Este guia detalha como gerar arquivos de relatório de forma programática por meio do serviço de relatórios.

Encontrar um relatório

Para gerar um relatório, você precisa saber o código dele. Se você tiver acabado de criar ou atualizar um relatório, encontre esse valor no campo id do recurso de relatório retornado. É recomendável que os usuários armazenem esses IDs retornados para uma pesquisa posterior.

Se não souber o ID do relatório que deseja gerar, você pode procurar na lista de todos os relatórios disponíveis. O exemplo abaixo ilustra como procurar um relatório por alguns critérios definidos pelo usuário:

C#

Report target = null;
ReportList reports;
String nextPageToken = null;

do {
  // Create and execute the reports list request.
  ReportsResource.ListRequest request = service.Reports.List(profileId);
  request.PageToken = nextPageToken;
  reports = request.Execute();

  foreach (Report report in reports.Items) {
    if (IsTargetReport(report)) {
      target = report;
      break;
    }
  }

  // Update the next page token.
  nextPageToken = reports.NextPageToken;
} while (target == null
    && reports.Items.Any()
    && !String.IsNullOrEmpty(nextPageToken));

Java

Report target = null;
ReportList reports;
String nextPageToken = null;

do {
  // Create and execute the reports list request.
  reports = reporting.reports().list(profileId).setPageToken(nextPageToken).execute();

  for (Report report : reports.getItems()) {
    if (isTargetReport(report)) {
      target = report;
      break;
    }
  }

  // Update the next page token.
  nextPageToken = reports.getNextPageToken();
} while (target == null
    && !reports.getItems().isEmpty()
    && !Strings.isNullOrEmpty(nextPageToken));

PHP

$target = null;
$response = null;
$pageToken = null;

do {
    // Create and execute the report list request.
    $response = $this->service->reports->listReports(
        $userProfileId,
        ['pageToken' => $pageToken]
    );

    foreach ($response->getItems() as $report) {
        if ($this->isTargetReport($report)) {
            $target = $report;
            break;
        }
    }

    $pageToken = $response->getNextPageToken();
} while (empty($target) && !empty($response->getItems()) && !empty($pageToken));

Python

target = None

# Construct the request.
request = service.reports().list(profileId=profile_id)

while True:
  response = request.execute()

  for report in response['items']:
    if is_target_report(report):
      target = report
      break

  if not target and response['items'] and response['nextPageToken']:
    request = service.reports().list_next(request, response)
  else:
    break

Ruby

page_token = nil
target = nil

loop do
  result = service.list_reports(profile_id, page_token: page_token)

  result.items.each do |report|
    if target_report?(report)
      target = report
      break
    end
  end

  page_token = (result.next_page_token if target.nil? && result.items.any?)
  break if page_token.to_s.empty?
end

Consulte a documentação de referência e veja os parâmetros opcionais que você pode especificar para controlar como a lista de relatórios retornados é classificada e ordenada. Controlar a classificação e a ordem dessa lista pode ser especialmente útil para encontrar relatórios que foram modificados recentemente.

Gerar um relatório

Depois de encontrar um relatório adequado, você poderá usar o serviço de geração de relatórios para gerá-lo e gerar um novo arquivo de relatório. Os relatórios podem ser gerados de forma síncrona ou assíncrona (padrão), dependendo da complexidade do relatório e do tempo necessário para processá-lo. Consulte o guia Relatórios síncronos para ver detalhes sobre relatórios síncronos e assíncronos.

Para gerar um relatório, você faz uma chamada para o método de execução do serviço de relatórios, como no exemplo abaixo:

C#

// Run the report.
File file = service.Reports.Run(profileId, reportId).Execute();

Java

// Run the report.
File file = reporting.reports().run(profileId, reportId).execute();

PHP

// Run the report.
$file = $this->service->reports->run($userProfileId, $reportId);

Python

# Run the report.
report_file = service.reports().run(
    profileId=profile_id, reportId=report_id).execute()

Ruby

# Run the report.
report_file = service.run_report(profile_id, report_id)

A resposta a essa solicitação é um recurso Files. Se a solicitação de execução síncrona for bem-sucedida, todos os campos do recurso retornado serão preenchidos e o arquivo estará pronto para o download. No entanto, como essa era uma solicitação de execução assíncrona, determinados campos da chave estarão ausentes e o status do arquivo será definido como PROCESSING, já que a geração do relatório ainda não foi concluída.

Observação: se a geração de um relatório síncrono demorar muito tempo para ser concluída, ela será automaticamente convertida em uma geração de relatório assíncrono. Sempre verifique o campo status do recurso de arquivo retornado para determinar se a geração de um relatório realmente foi concluída.

Quando a geração de um relatório foi concluída?

Quando você gera um relatório de forma assíncrona, um arquivo de marcador é gerado imediatamente e o relatório é colocado em uma fila para ser processado. O marcador conterá duas informações-chave para ajudar a determinar quando a geração do relatório foi concluída:

1. Um campo id, que pode ser usado para referenciar esse arquivo em solicitações subsequentes.
2. Um campo status, que representa o estado atual da geração do relatório.

Para determinar quando a geração de um relatório foi concluída, verifique periodicamente o status do arquivo, como no exemplo abaixo:

C#

// Wait for the report file to finish processing.
// An exponential backoff policy is used to limit retries and conserve quota.
int sleep = 0;
int startTime = GetCurrentTimeInSeconds();
do {
  File file = service.Files.Get(reportId, fileId).Execute();

  if ("REPORT_AVAILABLE".Equals(file.Status)) {
    Console.WriteLine("File status is {0}, ready to download.", file.Status);
    return;
  } else if (!"PROCESSING".Equals(file.Status)) {
    Console.WriteLine("File status is {0}, processing failed.", file.Status);
    return;
  } else if (GetCurrentTimeInSeconds() - startTime > MAX_RETRY_ELAPSED_TIME) {
    Console.WriteLine("File processing deadline exceeded.");
    return;
  }

  sleep = GetNextSleepInterval(sleep);
  Console.WriteLine("File status is {0}, sleeping for {1} seconds.", file.Status, sleep);
  Thread.Sleep(sleep * 1000);
} while (true);

Java

BackOff backOff =
    new ExponentialBackOff.Builder()
        .setInitialIntervalMillis(10 * 1000) // 10 second initial retry
        .setMaxIntervalMillis(10 * 60 * 1000) // 10 minute maximum retry
        .setMaxElapsedTimeMillis(60 * 60 * 1000) // 1 hour total retry
        .build();

do {
  File file = reporting.files().get(reportId, fileId).execute();

  if ("REPORT_AVAILABLE".equals(file.getStatus())) {
    // File has finished processing.
    System.out.printf("File status is %s, ready to download.%n", file.getStatus());
    return file;
  } else if (!"PROCESSING".equals(file.getStatus())) {
    // File failed to process.
    System.out.printf("File status is %s, processing failed.", file.getStatus());
    return null;
  }

  // The file hasn't finished processing yet, wait before checking again.
  long retryInterval = backOff.nextBackOffMillis();
  if (retryInterval == BackOff.STOP) {
    System.out.println("File processing deadline exceeded.%n");
    return null;
  }

  System.out.printf("File status is %s, sleeping for %dms.%n", file.getStatus(), retryInterval);
  Thread.sleep(retryInterval);
} while (true);

PHP

// Wait for the report file to finish processing.
// An exponential backoff policy is used to limit retries and conserve
// quota.
$sleep = 0;
$startTime = time();

do {
    $file = $this->service->files->get($reportId, $fileId);

    if ($file->getStatus() === 'REPORT_AVAILABLE') {
        printf('File status is %s, ready to download<br>', $file->getStatus());
        return $file;
    } elseif ($file->getStatus() !== 'PROCESSING') {
        printf('File status is %s, processing failed<br>', $file->getStatus());
        return null;
    } elseif (time() - $startTime > self::MAX_RETRY_ELAPSED_TIME) {
        printf('File processing deadline exceeded<br>');
        return null;
    }

    $sleep = $this->getNextSleepInterval($sleep);
    printf(
        'File status is %s, sleeping for %d seconds<br>',
        $file->getStatus(),
        $sleep
    );
    $this->sleep($sleep);
} while (true);

Python

# Wait for the report file to finish processing.
# An exponential backoff strategy is used to conserve request quota.
sleep = 0
start_time = time.time()
while True:
  report_file = service.files().get(
      reportId=report_id, fileId=file_id).execute()

  status = report_file['status']
  if status == 'REPORT_AVAILABLE':
    print 'File status is %s, ready to download.' % status
    return
  elif status != 'PROCESSING':
    print 'File status is %s, processing failed.' % status
    return
  elif time.time() - start_time > MAX_RETRY_ELAPSED_TIME:
    print 'File processing deadline exceeded.'
    return

  sleep = next_sleep_interval(sleep)
  print 'File status is %s, sleeping for %d seconds.' % (status, sleep)
  time.sleep(sleep)

Ruby

# Wait for the report file to finish processing.
# An exponential backoff strategy is used to conserve request quota.
interval = 0
start_time = Time.now
loop do
  report_file = service.get_file(report_id, file_id)

  status = report_file.status
  if status == 'REPORT_AVAILABLE'
    puts format('File status is %s, ready to download.', status)
    break
  elsif status != 'PROCESSING'
    puts format('File status is %s, processing failed.', status)
    break
  elsif Time.now - start_time > MAX_RETRY_ELAPSED_TIME
    puts 'File processing deadline exceeded.'
    break
  end

  interval = next_sleep_interval(interval)
  puts format('File status is %s, sleeping for %d seconds.', status,
    interval)
  sleep(interval)
end

Quando o status mudar para REPORT_AVAILABLE, o arquivo estará pronto para o download. Como mostrado no exemplo acima, é altamente recomendável implementar uma estratégia de backoff exponencial durante a pesquisa como essa para otimizar o uso da cota de solicitações.