opts.Storage = true
		opts.OS = true
		// Older mc - cannot deal with more types...
	}
	return opts, err
}

// TraceHandler - POST /minio/admin/v3/trace
// ----------
// The handler sends http trace to the connected HTTP client.
func (a adminAPIHandlers) TraceHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	// Validate request signature.

                }
                file.send(reqx, rspx);
                fp += rspx.count;
                len -= rspx.count;
                off += rspx.count;
            } else {
                req.setParam(file.fid, fp, len - w, b, off, w);
                fp += rsp.count;
                len -= rsp.count;
                off += rsp.count;
                file.send(req, rsp);
            }

                }
            });
        } catch (final Exception e) {
            logger.warn("Failed to write thread dump: file={}", file, e);
        }
    }

    /**
     * Processes all thread information and sends it to the provided consumer.
     *
     * @param writer the consumer that will handle each line of thread dump output
     */
    public static void processThreadDump(final Consumer<String> writer) {

Para isso você precisa acessar a requisição diretamente.

{* ../../docs_src/using_request_directly/tutorial001_py310.py hl[1,7:8] *}

Ao declarar o parâmetro com o tipo sendo um `Request` em sua *função de operação de rota*, o **FastAPI** saberá como passar o `Request` neste parâmetro.

/// tip | Dica

Note que neste caso, nós estamos declarando o parâmetro de path ao lado do parâmetro da requisição.

	auditTotalMessages     = "total_messages"
	targetID               = "target_id"
)

var (
	auditFailedMessagesMD = NewCounterMD(auditFailedMessages,
		"Total number of messages that failed to send since start",
		targetID)
	auditTargetQueueLengthMD = NewGaugeMD(auditTargetQueueLength,
		"Number of unsent messages in queue for target",
		targetID)
	auditTotalMessagesMD = NewCounterMD(auditTotalMessages,

* the performance: NOT die Performance
* the query: die Query
* the recap: die Zusammenfassung
* the request (what the client sends to the server): der Request
* the request body: der Requestbody
* the request bodies (plural): die Requestbodys
* the response (what the server sends back to the client): die Response
* the return type: der Rückgabetyp
* the return value: der Rückgabewert

After configuring the plugin, use the generated Role ARN with `AssumeRoleWithCustomToken` to get temporary credentials to access object storage.

## API Request

To make an STS API request with this method, send a POST request to the MinIO endpoint with following query parameters:

| Parameter       | Type    | Required |                                                                      |

        .build(),
    )

    val request =
      HttpRequest
        .newBuilder(server.url("/").toUri())
        .header("Accept", "text/plain")
        .build()

    val response = httpClient.send(request, BodyHandlers.ofString())
    assertThat(response.statusCode()).isEqualTo(200)
    assertThat(response.body()).isEqualTo("hello, Java HTTP Client")

    val recorded = server.takeRequest()

    yield ServerSentEvent(data={"status": "started"}, event="status", id="1")
    yield ServerSentEvent(data={"progress": 50}, event="progress", id="2")
```

Use `raw_data` instead of `data` to send pre-formatted strings without JSON encoding:

```python
yield ServerSentEvent(raw_data="plain text line", event="log")
```

## Stream bytes

/// tip | Dica

Você pode definir uma sobreposição de dependência para uma dependência que é utilizada em qualquer lugar da sua aplicação **FastAPI**.

A dependência original pode estar sendo utilizada em uma *função de operação de rota*, um *decorador de operação de rota* (quando você não utiliza o valor retornado), uma chamada ao `.include_router()`, etc.

O FastAPI ainda poderá sobrescrevê-la.

///