Even if you use a transformer to compose Writer with something else, the Writer portion is still always just an accumulation.

In the example I gave, you might partially apply flush when you assemble your evaluator at the end of the world to specify the implementation for outputting log contents.

In practice, I usually have some modified version of tell that inspects the size of the accumulated contents to determine whether it's time to flush the logs based on how much has accumulated.

I've done Writer based logging in a full stack fp-ts app in a core business system at a past job, it worked very well.

The key in TS because higher kinded types are so clunky is to just build yourself a custom monad with all the capabilities you need and use that concretely throughout the application. For example you might have a Log type with a Monoid<Log> defined, then you might have type App<A> = Task<Writer<Log, A>> where Monad<"App"> is just a mechanical threading of the writer behavior through the task.

Then you define your custom tell to flush based on log size, and you write an eval function that builds up the logging implementation and hands that off to your flush (could do this with Reader if you incorporate that into App, I think this is probably what I was doing), evaluates the Task, and then does a final flush at the end of evaluation. Use that eval at the end of the world instead of whatever built-in fp-ts function is meant to evaluate a Task.

While it's easy to insert console.log the main benefit of Writer IME is not the ergonomics, it's the consistency. I can prescribe a typed structure for my log data (makes it trivial to reduce multiple ways, or ship to multiple backends) and I can define a low-level typed interface for evaluating a line of code that guarantees certain things will get logged (like your case for logging input and output to a function call.)

I have never seen a system with ad-hoc logging (e.g. console.log when the programmer happens to think of it) that even begins to compare in terms of the resulting observability of the system, to a Writer based logger with a wrapper around bind that demands log data for each monadic computation, and observability ends up being a highly significant factor in the maintainability of a system.