Berichte suchen und erstellen

Nachdem Sie einen Bericht gefunden oder erstellt haben, der Ihren Anforderungen entspricht, können Sie die Ausgabe generieren. Die Berichtsausgabe wird in Berichtsdateien gespeichert, die programmatisch abgerufen und bearbeitet werden können. Eine Berichtsdatei wird als Ergebnis der Ausführung eines Berichts erstellt.

In dieser Anleitung erfahren Sie, wie Sie Berichtsdateien programmatisch über den Reports-Dienst generieren.

Bericht suchen

Um einen Bericht auszuführen, benötigen Sie die ID des Berichts. Wenn Sie gerade einen Bericht erstellt oder aktualisiert haben, finden Sie diesen Wert im Feld id der zurückgegebenen Berichtsressource. Nutzer sollten diese zurückgegebenen IDs für die spätere Suche speichern.

Wenn Sie die ID des Berichts, den Sie ausführen möchten, nicht kennen, können Sie die Liste aller verfügbaren Berichte durchsuchen, um den gewünschten Bericht zu finden. Im folgenden Beispiel wird gezeigt, wie Sie einen Bericht anhand einiger benutzerdefinierter Kriterien suchen:

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=str(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

In der Referenzdokumentation finden Sie optionale Parameter, mit denen Sie festlegen können, wie die Liste der zurückgegebenen Berichte sortiert und geordnet wird. Die Sortierung und Reihenfolge dieser Liste kann besonders nützlich sein, um Berichte zu finden, die kürzlich geändert wurden.

Bericht erstellen

Wenn Sie einen geeigneten Bericht gefunden haben, können Sie ihn mit dem Report-Dienst ausführen und eine neue Berichtsdatei generieren. Berichte können je nach Komplexität und Verarbeitungszeit synchron oder asynchron (Standard) ausgeführt werden. Weitere Informationen zu synchronen und asynchronen Berichten finden Sie im Leitfaden zu synchronen Berichten.

Um einen Bericht auszuführen, rufen Sie die Methode „run“ des Report-Dienstes auf, wie im folgenden Beispiel:

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=str(profile_id), reportId=str(report_id))
    .execute()
)

Ruby

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

Die Antwort auf diese Anfrage ist eine Files-R/essource. Wenn es sich um eine erfolgreiche synchrone Ausführungsanfrage handelt, sind alle Felder der zurückgegebenen Ressource ausgefüllt und die Datei kann heruntergeladen werden. Da es sich jedoch um eine asynchrone Ausführungsanfrage handelt, fehlen bestimmte Schlüsselfelder und der status der Datei ist auf PROCESSING gesetzt, da die Ausführung des Berichts noch nicht abgeschlossen ist.

Hinweis: Wenn die Ausführung eines synchronen Berichts zu lange dauert, wird sie automatisch in eine asynchrone Ausführung umgewandelt. Prüfen Sie immer das Feld status der zurückgegebenen Dateiressource, um festzustellen, ob die Ausführung eines Berichts tatsächlich abgeschlossen ist.

Wann ist die Ausführung eines Berichts abgeschlossen?

Wenn Sie einen Bericht asynchron ausführen, wird sofort eine Platzhalterdatei generiert und der Bericht wird in eine Warteschlange zur Verarbeitung gestellt. Der Platzhalter enthält zwei wichtige Informationen, mit denen Sie feststellen können, wann die Ausführung des Berichts abgeschlossen ist:

1. Ein Feld id, mit dem Sie in nachfolgenden Anfragen auf diese Datei verweisen können.
2. Ein Feld status, das den aktuellen Status der Berichtsausführung darstellt.

Um festzustellen, wann die Ausführung eines Berichts abgeschlossen ist, müssen Sie den status der Datei regelmäßig prüfen, wie im folgenden Beispiel:

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=str(report_id), fileId=str(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

Wenn sich der status in REPORT_AVAILABLE ändert, kann die Datei heruntergeladen werden. Wie im obigen Beispiel gezeigt, wird dringend empfohlen, bei solchen Abfragen eine exponentielle Backoff-Strategie zu implementieren, um die Nutzung Ihres Anfragekontingents zu optimieren.