// HelpDrive is help for drive
	HelpDrive = config.HelpKVS{
		config.HelpKV{
			Key:         MaxTimeout,
			Type:        "string",
			Description: "set per call max_timeout for the drive, defaults to 30 seconds",
			Optional:    true,
		},
	}

      }
    }
  }

  fun takeAll(): List<String> {
    val list = mutableListOf<String>()
    logs.drainTo(list)
    return list
  }

  fun take(): String {
    return logs.poll(10, TimeUnit.SECONDS)
      ?: throw AssertionError("Timed out waiting for log message.")
  }

			Optional:    true,
			Type:        "string",
		},
		config.HelpKV{
			Key:         browserHSTSSeconds,
			Description: `set Strict-Transport-Security 'max-age' amount of seconds value` + defaultHelpPostfix(browserHSTSSeconds),
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         browserHSTSIncludeSubdomains,

      (this as Object).wait(timeoutMillis - nowMillis)
    }

    throw AssertionError("Timed out waiting for response to $url")
  }

  companion object {
    val TIMEOUT_MILLIS = TimeUnit.SECONDS.toMillis(10)
  }

      System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f)
      call.cancel()
      System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f)
    }, 1, TimeUnit.SECONDS)

    System.out.printf("%.2f Executing call.%n", (System.nanoTime() - startNanos) / 1e9f)
    try {
      call.execute().use { response ->
        System.out.printf(

      .isCloseTo(now.toDouble(), deltaMillis)
    assertThat(certificate.notAfter.time.toDouble())
      .isCloseTo(now.toDouble() + durationMillis, deltaMillis)
  }

  @Test
  fun customInterval() {
    // 5 seconds starting on 1970-01-01.
    val heldCertificate =
      HeldCertificate.Builder()
        .validityInterval(5000L, 10000L)
        .build()
    val certificate = heldCertificate.certificate

	if w != nil {
		// Increment the prometheus http request response histogram with API, Bucket
		bucketHTTPRequestsDuration.With(prometheus.Labels{
			"api":    api,
			"bucket": bucket,
		}).Observe(w.TTFB().Seconds())
	}

	bh.Lock()
	defer bh.Unlock()

	hstats, ok := bh.httpStats[bucket]
	if !ok {
		hstats = bucketHTTPAPIStats{
			currentS3Requests: &HTTPAPIStats{},
			totalS3Requests:   &HTTPAPIStats{},

And also after the `response` is generated, before returning it.

For example, you could add a custom header `X-Process-Time` containing the time in seconds that it took to process the request and generate a response:

```Python hl_lines="10  12-13"
{!../../docs_src/middleware/tutorial001.py!}
```

/// tip

    github_event = PartialGitHubEvent.parse_raw(contents)

    # Avoid race conditions with multiple labels
    sleep_time = random.random() * 10  # random number between 0 and 10 seconds
    logging.info(
        f"Sleeping for {sleep_time} seconds to avoid "
        "race conditions and multiple comments"
    )
    time.sleep(sleep_time)

    # Get PR
    logging.debug(f"Processing PR: #{github_event.pull_request.number}")

    assertThrows(TimeoutException.class, () -> manager.awaitHealthy(1, MILLISECONDS));
    manager.awaitHealthy(5, SECONDS); // no exception thrown

    manager.stopAsync();
    assertThrows(TimeoutException.class, () -> manager.awaitStopped(1, MILLISECONDS));
    manager.awaitStopped(5, SECONDS); // no exception thrown
  }

  /**