@Dmitry Kandalov it's been a while now, but I seem to recall that it was added purely as an aid to testing, so the order of added headers was disregarded when performing a comparison. I for one have never actually ever used it in prod code.

Hey sorry to pester the channel, but could someone take a look at this PR please: https://github.com/http4k/http4k/pull/277

New proposal: support for Google Cloud Endpoints

x-google-endpoints

extension for OpenAPI: https://cloud.google.com/endpoints/docs/openapi/openapi-extensions#x-google-endpoints

@Razi Kheir Unfortunately, that depends a bit on the client implementation. Which one are you using?

If anyone wants to chip in with things you've found good (or bad 🙃) when starting off then that would be great: https://www.reddit.com/r/Kotlin/comments/d06za9/ktor_vs_http4k/

@Alfi Thanks for your kind words. Looks like you've found a problem - I've raised and fixed #291. The release with it in is 3.180.0 and is releasing now. 🙂

Has anyone seen this before and know what I'm doing wrong here? Happy to provide a reproducible example

main.kt

file if it's useful.

Does the order matter when applying filters? Is there any significant difference in the order that server, request, and response filters need to be applied?

we can't use nulls to generate a valid schema, so we blow up

if you use the API, it should handle all that for you

@RajanS it should be working fine. when you say "in the swagger" - do you mean the JSON doc (say the example section of the definition), or are you having problems with the actual marshaling of the service? A Gist showing what you're seeing would help to diagnose if there is a problem

Hi David, Im getting the following exception after upgrading from

3.179.0

to 3.185.0`

Exception in thread "main" java.lang.NoSuchMethodError: java.lang.Class.getPackageName()Ljava/lang/String;
	at org.http4k.core.MimeTypes$Companion.loadStandard(MimeTypes.kt:29)
	at org.http4k.core.MimeTypes$Companion.access$loadStandard(MimeTypes.kt:12)
	at org.http4k.core.MimeTypes$Companion$standardTypes$2.invoke(MimeTypes.kt:16)
	at org.http4k.core.MimeTypes$Companion$standardTypes$2.invoke(MimeTypes.kt:12)
	at kotlin.SynchronizedLazyImpl.getValue(LazyJVM.kt:74)
	at org.http4k.core.MimeTypes$Companion.getStandardTypes(MimeTypes.kt)
	at org.http4k.core.MimeTypes$Companion.invoke(MimeTypes.kt:14)
	at org.http4k.routing.ResourceLoadingHandler.<init>(internal.kt:24)
	at org.http4k.routing.StaticRoutingHttpHandler.<init>(internal.kt:55)
	at org.http4k.routing.StaticRoutingHttpHandler.<init>(internal.kt:48)
	at org.http4k.routing.RoutingKt.static(routing.kt:57)
	at com.johnlewis.recommendations.controller.ApiHandler.invoke(ApiHandler.kt:111)
	at com.johnlewis.recommendations.Application.<init>(Application.kt:57)
	at com.johnlewis.recommendations.ApplicationKt.main(Application.kt:89)
	at com.johnlewis.recommendations.ApplicationKt.main(Application.kt)

This happens for StaticRoutingHandler serving static content.

hi guys, I wonder what battle tested http client anyone can recommend to use in our http4k app. We started off with OkHttp. One team reported problems: 1. The default

org.http4k.client.OkHttp()

use default OkHttp configuration and it seems it is optimized for single user application. 2. the team moved to creating OkHttp with their customized connection pooling configuration but it does not seem to pass their performance testing in some cases. The team has therefor moved away from OkHttp and started using

org.eclipse.jetty.client.HttpClient

. We thought to use

org.eclipse.jetty.client.HttpClient

instead as well given their experience. But thought to seek some recommendation here.

@Razi Kheir you can obviously do either, but personally I prefer the path based routing, especially when using the contracts module with OpenApi as it makes it very clear in the docs that both exist and the different request/response types that can be present for each - also this multi-message type is actually something that the swagger UI does not currently support (or at least last time I checked). The approach also makes the overall route handler code easier to read and to test - less logic == simpler. 🙃 . And when it comes time to remove the old routes you can just delete the entire old code instead of having to unpick the switching logic for the latest version from the old.

I’m having an issue creating a jettyClient with a connection pool. The JettyClient expects an HttpClient while this one returns an object that is a ClosableHttpClient

Another question, I have the following filters set up on my handler:

ServerFilters.RequestTracing()
      .then(ServerFilters.SetContentType(ContentType.APPLICATION_JSON))
            .then(logAPIRequestFilter())
            .then(ServerFilters.Cors(corsPolicy))
            .then(NoCache())
            .then(exceptionToErrorResponseFilter())
            .then(lensExceptionFilter())
            .then(apiHandler)
`

But for some reason cache control headers are not being returned when I curl (both for responses bigger, smaller than 400 (tried also override and writing true, still didn’t return it)

Hey folks 🙂 What would be your recommended way of creating an environment config from multiple `EnvironmentKey`s ? Say I want to create an instance of

data class MongoDBSettings(val host: String, val port: Int)

from the environment variables

MONGO_HOST

and

MONGO_PORT

. Would I have them as separate `EnvironmentKey`s and do the mapping outside or is there some lens magic where I can do something like

EnvironmentKey.mongoSettings().required("MONGO_HOST", "MONGO_PORT")

?

I was wondering something regarding lenses. Should I define a lens such as this:

Body.auto<RequestBody>().toLens()

Once as a constant and use it inside of other methods? Or write it inside of a method? I guess what i’m asking if it will be recreated every time in the method with no reason :x

I was wondering how to add RequestTracing to my client (for outgoing calls). Or any other headers. I just want my client to automatically attach some headers to all calls outgoing through it such as tracing, content type, etc. Or can those only be added on the request level I wonder

Hi David, I was wondering how to do percentile metrics using http4k ?

@dave https://www.http4k.org/cookbook/request_context/ I’m using context key to save/retrieve a context of a request for logging purposes. I was wondering, do you guys pass that context on the main handler of your route and pass it down to relevant methods for logging, or do you pass down the request itself and lens out the context every time you log.

Does http4k have built in DI? Or an easy way to integrate it

Is anyone using GraphQL with http4k? Have you integrated it successfully with the `Request`/`Response` flow that http4k servers/clients use?

It's for Jade4J fyi

Hi, is there a way to add additional behaviour to

server.start()

? so that a connection to a message broker can be established on start, other than implementing the

Http4kServer

interface myself

@Razi Kheir for the second question, you can use a composite object: https://github.com/http4k/http4k/blob/93071c49e93b74798869721b5dddae9367d33f84/http4k-core/src/test/kotlin/org/http4k/lens/BiDiLensSpecTest.kt#L123

For the first, this should definitely work. Could you just put together a tiny example and post it here or in a gist, and we'll take look?

I'm playing with KotlinNative for a Demo, is someone ever tried a port of Http4k to KN?

Hey, I was wondering if it is possible for body auto marshalling lenses to pick up @field:Json. I want to have different name for internal variable vs incoming one, it seems as though ignores that flag and doesnt unmarshal those fields

@Razi Kheir you can do either TBH - there are points to be made on either side- a single port gives you the ability to know that your main server instance definitely isn't choking, but you then have internal traffic mixed up with your normal API traffic which can be a security thing (that otherwise needs to be solved another way). If you do want to put them on the same port, you can just compose an instance of

Health

into your main routes definition block.