tpolecat/natchez

Ryan Zeigler

@rzeigler

and then the individual drivers can make use

Jente Hidskes

@Hjdskes

Hey folks! Is there a slightly more involved piece of code that I can study somewhere that uses Natchez? I'm particularly struggling to integrate this into my existing codebase which is structured after Gabriel Volpe's book (https://github.com/gvolpe/pfps-shopping-cart). Because the algebras and interpreters are all created before requests start coming in, I can't (as far as I know at least) simply put a Trace[F] in the context bound for those and call it a day.

Anton Solovyev

@Rosteelton

Hi! Need some help with wiring with natchez.
I have one big wire function:

  def wireAll[F[_]: ContextShift: Timer: Parallel: Concurrent: Async]: Resource[F, HttpRoutes[F]]

And one run function:

def run[F[_]: ContextShift: ConcurrentEffect: Timer: Parallel: Bracket[*[_], Throwable]]: F[Fiber[F, Unit]] = {
  val resource =  for {
    traceEntryPoint <- entryPoint[F]: Resource[F, EntryPoint[F]]
    httpRoutes <- wireAll[Kleisli[F, Span[F], *]]: Resource[Kleisli[F, Span[F], *], HttpRoutes[Kleisli[F, Span[F], *]]
  //after that I can obtain HttpRoutes[F] from HttpRoutes[Kleisli[F, Span[F], *] using middleware and run server
  ...
  } yield ()
...
}

The problem is in the first Resource type parameter - Kleisli[F, Span[F], *] (F needed)
Do you know how to rewrite this correctly?

Jakub Kozłowski

@kubukoz

@Rosteelton I would suggest that you mapK from that resource Resource[Kleisli[F, Span[F], *], HttpRoutes[Kleisli[F, Span[F], *]] to Resource[F, HttpRoutes[Kleisli[F, Span[F], *]]. You'll need a Kleisli[F, Span[F], *] ~> F

which is basically Kleisli.applyK, but you'll still need a Span[F]. You can probably use one that you get from the entrypoint - this will basically be the span of "starting the application"

I'm not sure I explained that well

httpRoutes <- traceEntryPoint.root("init").use { span => wireAll[Kleisli[F, Span[F], *]].mapK(Kleisli.applyK(span)) } - roughly

I didn't compile that though

btw. I wouldn't recommend this shape F[Fiber[F, Unit]], it's easy to make a mistake. See if you can use .background instead of .start wherever it is.

Anton Solovyev

@Rosteelton

@kubukoz Thanks! Helped a lot!

Jakub Kozłowski

@kubukoz

glad :)

Anton Solovyev

@Rosteelton

It's me again. I am trying to wrap Client[F]. (I have Trace[F] instance there)

  def apply[F[_]: Trace: Sync](client: Client[F]): Client[F] = {
    Client[F] { request =>
      val spanName: String = ???
      for {
        b <- Trace[F].span(spanName) { //should be F[]
          }
      //only have Resource[F, Response[F]] type for
      //client.run(modifiedRequest))
      } yield ???
    }
  }

Can't get how to transform Resource to wrap it with Trace[F].span

Ryan Zeigler

@rzeigler

You can use the Trace[F].span wherever you use the Response[F] rather than during construction time.

Anton Solovyev

@Rosteelton

Yes, but I would like to wrap all endpoints that this client will call.

Ryan Zeigler

@rzeigler

So spans are produced in their own resource. You might have to work directly in Kleisli to extract the span and produce a child span directly inside that resource.

Christopher Davenport

@ChristopherDavenport

I built a middleware specifically for that in http4s.

https://github.com/http4s/http4s/blob/main/client/src/main/scala/org/http4s/client/Client.scala#L223

Adam Rosien

@arosien

that's like an fp haiku

run map apply
map lift
map map lift
grasshopper

Anton Solovyev

@Rosteelton

@rzeigler I can't get one moment. In that case I will get Client[Kleisli[F, Span[F], *]. But all my code there doesn't know anything about Kleisli (I have only F[_]: Trace)

Ryan Zeigler

@rzeigler

So, what I would suggest you do is write http4s client middleware that does what you want. If the F[_] is in fact Kleisli[F, Span[F], *] then you can decorate the client ahead of time.

You would do this while your are wiring up your client and you should be mostly operating in concrete monads anyway

Christopher Davenport

@ChristopherDavenport

Right, pass in your client as an argument that's already middlewared up.

Bradford Toney

@bluemoon

So i'm looking to implement natchez and I understand that kleisli does not work with ConcurrentEffect, some of my program has it anyways. If I'm trying to work around it do I want do something like keeping my effect as F[_] and then using Kleisli.liftK on the specific code I'm working with or are there better ways to do this? (I'm fairly new to Kleisli and how best to handle this)

Ryan Zeigler

@rzeigler

So, one thing that is worth mentioning, you can usually implement an algebra in F that requires ConcurrentEffect and then use FunctorK type things to lift into the Kleisli. You won't be able to trace through the algebra that needs the ConcurrentEffect bound, but you can integrate it in the rest of the system. The implementation of mapK can sometimes even be done for you using cats-tagless.

Bradford Toney

@bluemoon

That makes sense, it sounds like i'll need to "flatten" (reconfigure the bounds of ConcurrentEffect) some of my algebras so that it works nicely, I'll have a look at cats-tagless as well

Gavin Bisesi

@Daenyth

:wave: Hey folks. Is there a microsite for natchez, or any documentation beside scaladoc+readme?

@bluemoon it doesn't help you today, but some good news: in CE3 you won't have that problem

Rob Norris

@tpolecat

@Daenyth no, it needs doc. Note the version number. People just started using it anyway.

Gavin Bisesi

@Daenyth

No criticism on that score :)

just scoping out what's there - it's an ecosystem niche with no mature options

natchez generally should beat "do it in-house" regardless of version

Rob Norris

@tpolecat

I would welcome any contribution on that front. There’s not a lot to it really.

Generalizing the Kleisli instance to Local would also be good.

Gavin Bisesi

@Daenyth

I'm not familiar enough with the tooling to know what needs doing

if there was a baseline "just copies the readme" microsite with editable pages that's probably enough to start gathering PRs

Rob Norris

@tpolecat

There's a lot going on. I need to make a persistent branch for ce3 and I can copy/paste the doc setup from skunk while I'm in there.

Gavin Bisesi

@Daenyth

:+1:

Ryan Zeigler

@rzeigler

Related to the Kleisli instance we actually have a LensedSpan type class that we use to pack different bits it with the span and produces Trace using the explicit lens operation on Kleisli trace. I can PR this if something you would want (and it would save us in the long term from a random implicit import).

We are a little behind I just hate upgrading those components because grpc has no concept of compatibility from what I can tell

Rob Norris

@tpolecat

Yeah I need to look at how the auto-lens stuff works.

There are way too many fires burning atm. Between Scala 3 and CE3 there's not a lot of time for extinguishing other things.

Keir Lawson

@keirlawson

Anyone any success combining Natchez with fs2? struggling a little as to how to combine .span which wants a Kleisli[F, Span[F], A] and the type I want to produce which is a fs2.Stream[Kleisli[F, Span[F], *], A]

Ryan Zeigler

@rzeigler

Are you trying to track how long the entire stream runs or individual operations within it?

Keir Lawson

@keirlawson

The entire stream

Ryan Zeigler

@rzeigler

You can stick a span around the compile action.

i.e. Trace[F].span(“stream”)(s.compile.drain)

Rob Norris

@tpolecat

There is a lingering PR to create a Trace instance for streams but I haven’t had any time to think about it.

Keir Lawson

@keirlawson

@rzeigler I'm wanting to pass back the traced stream elsewhere though, rather than turn it into an F at the point of adding the tracing

Ryan Zeigler

@rzeigler

So, the alternative option (and I haven't really exploded this, is that spans are resources yourself. I think you could probably define a pipe that traces a stream and does something like

Stream.eval(Kleisli.ask).flatMap(span => Stream.resource(span.subspan("name"))) >> innerStream

Where communities thrive

People

Repo info

Activity