}
        if (isQuery) {
            LaRequestUtil.getOptionalRequest().ifPresent(request -> {
                highlightedQuerySet = new HashSet<>();
                request.setAttribute(Constants.HIGHLIGHT_QUERIES, highlightedQuerySet);
                fieldLogMap = (Map<String, List<String>>) request.getAttribute(Constants.FIELD_LOGS);
                if (fieldLogMap == null) {

// specified in the quota configuration will be applied by default
// to enforce total quota for the specified bucket.
func (a adminAPIHandlers) PutBucketQuotaConfigHandler(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	objectAPI, _ := validateAdminReq(ctx, w, r, policy.SetBucketQuotaAdminAction)
	if objectAPI == nil {
		return
	}

	vars := mux.Vars(r)
	bucket := pathClean(vars["bucket"])

	"github.com/minio/minio/internal/pubsub"
)

// TraceParamsKey allows to pass trace parameters to the request via context.
// This is only needed when un-typed requests are used.
// MSS, map[string]string types are preferred, but any struct with exported fields will work.
type TraceParamsKey struct{}

// traceRequests adds request tracing to the connection.
func (c *Connection) traceRequests(p *pubsub.PubSub[madmin.TraceInfo, madmin.TraceType]) {

apiVersion: install.istio.io/v1alpha1
kind: IstioOperator
metadata:
  name: test
  namespace: istio-system
spec:
  meshConfig:
    # Set enableTracing to false to disable request tracing.
    enableTracing: true
    # This is the ingress service name, update if you used a different name
    ingressService: istio-ingress
    connectTimeout: 1s
    defaultConfig:
      ### ADVANCED SETTINGS #############

    server.useHttps(sslContext.getSocketFactory(), false);
    server.setDispatcher(this);
    server.start(port);
  }

  @Override public MockResponse dispatch(RecordedRequest request) {
    String path = request.getPath();
    try {
      if (!path.startsWith("/") || path.contains("..")) throw new FileNotFoundException();

      File file = new File(root + path);
      return file.isDirectory()

app = FastAPI()


@app.exception_handler(StarletteHTTPException)
async def http_exception_handler(request, exc):
    return PlainTextResponse(str(exc.detail), status_code=exc.status_code)


@app.exception_handler(RequestValidationError)
async def validation_exception_handler(request, exc):
    return PlainTextResponse(str(exc), status_code=400)


@app.get("/items/{item_id}")

    logWithTime("requestHeadersStart")

    delegate.requestHeadersStart(call)
  }

  override fun requestHeadersEnd(
    call: Call,
    request: Request,
  ) {
    logWithTime("requestHeadersEnd")

    delegate.requestHeadersEnd(call, request)
  }

  override fun requestBodyStart(call: Call) {
    logWithTime("requestBodyStart")

    delegate.requestBodyStart(call)
  }

        .build()

    server.enqueue(MockResponse(body = "abc1"))
    server.enqueue(MockResponse(body = "abc2"))

    val request = Request(server.url("/"))

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    assertThat(server).isSameInstanceAs(instanceServer)

    clientTestRule.newClient().newCall(Request(server.url("/"))).execute().use {
      assertThat(it.code).isEqualTo(200)
    }
  }

  @Test
  fun testClient2(server: MockWebServer) {
    assertThat(server).isSameInstanceAs(instanceServer)

    clientTestRule.newClient().newCall(Request(server.url("/"))).execute().use {
      assertThat(it.code).isEqualTo(200)
    }
  }

    private int maxReferralLevel = 3;

    private final DfsReferralRequestBuffer request;


    /**
     * 
     * @param config
     * @param filename
     */
    public Trans2GetDfsReferral ( Configuration config, String filename ) {
        super(config, SMB_COM_TRANSACTION2, TRANS2_GET_DFS_REFERRAL);
        this.request = new DfsReferralRequestBuffer(filename, 3);
        this.totalDataCount = 0;