var deploymentID string
	if entry.DeploymentID != "" {
		deploymentID = "\nDeploymentID: " + entry.DeploymentID
	}

	var requestID string
	if entry.RequestID != "" {
		requestID = "\nRequestID: " + entry.RequestID
	}

	var remoteHost string
	if entry.RemoteHost != "" {
		remoteHost = "\nRemoteHost: " + entry.RemoteHost
	}

	var host string
	if entry.Host != "" {

    private final Lock lock;

    private ResponseProducer producer = new ResponseProducer() {
        @Override
        public void writeTo(int requestId, HttpExchange exchange) throws IOException {
            responseBody.writeTo(requestId, exchange);
        }
    };
    private ResponseProducer responseBody = new SendFixedContent(200, "hi");
    private BlockingRequest blockingRequest;

	echo.LatencyField.WriteForRequest(&outBuffer, requestID, fmt.Sprintf("%v", time.Since(start)))
	echo.ActiveRequestsField.WriteForRequest(&outBuffer, requestID, fmt.Sprintf("%d", c.e.ActiveRequests()))

	// Process the response.
	err = processHTTPResponse(requestID, httpResp, &outBuffer)

	// Extract the output string.
	return outBuffer.String(), err
}

            }
        } finally {
            lock.unlock();
        }
    }

    @Override
    public void writeTo(int requestId, HttpExchange exchange) throws IOException {
        handler.writeTo(requestId, exchange);
    }

			base: `
proxyHeaders:
  requestId:
    disabled: true`,
			overlay: `
proxyHeaders:
  requestId:
    disabled: false`,
			result: `
proxyHeaders:
  requestId:
    disabled: false`,
		},
		{
			name: "enabled then disabled",
			base: `
proxyHeaders:
  requestId:
    disabled: false`,
			overlay: `
proxyHeaders:
  requestId:
    disabled: true`,
			result: `

			return msgBuilder.String(), err
		}
	}

	echo.ForwarderURLField.WriteForRequest(&msgBuilder, requestID, cfg.Request.Url)

	if cfg.Request.Message != "" {
		echo.ForwarderMessageField.WriteForRequest(&msgBuilder, requestID, cfg.Request.Message)
	}

	// Apply per-request timeout to calculate deadline for reads/writes.
	ctx, cancel := context.WithTimeout(ctx, cfg.timeout)

interface ResponseProducer {
    default boolean isFailure() {
        return false;
    }

    /**
     * Called to handle a request. Is *not* called under lock.
     */
    void writeTo(int requestId, HttpExchange exchange) throws IOException;

    /**
     * Returns the failure, if any.
     */
    default RuntimeException getFailure() {
        throw new IllegalStateException();
    }

	sync.RWMutex
}

// NewReqInfo :
func NewReqInfo(remoteHost, userAgent, deploymentID, requestID, api, bucket, object string) *ReqInfo {
	return &ReqInfo{
		RemoteHost:   remoteHost,
		UserAgent:    userAgent,
		API:          api,
		DeploymentID: deploymentID,
		RequestID:    requestID,
		BucketName:   bucket,
		ObjectName:   object,
	}
}

// AppendTags - appends key/val to ReqInfo.tags

			[]byte(nameData),
			[]byte(valueData),
		},
		nil,
	)
}

func makeRecord(
	recordType recType,
	requestId uint16,
	contentData []byte,
) []byte {
	requestIdB1 := byte(requestId >> 8)
	requestIdB0 := byte(requestId)

	contentLength := len(contentData)
	contentLengthB1 := byte(contentLength >> 8)
	contentLengthB0 := byte(contentLength)
	return bytes.Join([][]byte{

	Error   struct {
		Type    string `xml:"Type"`
		Code    string `xml:"Code"`
		Message string `xml:"Message"`
	} `xml:"Error"`
	RequestID string `xml:"RequestId"`
}

// STSErrorCode type of error status.
type STSErrorCode int

//go:generate stringer -type=STSErrorCode -trimprefix=Err $GOFILE