Everybody needs logs. Humans and machines. Logs should be structured, json and text format. The library should be modular, provide full customization of the router, rendering policies, sinks, dynamic client context. What if we could provide such logging library with compile-time structure and context extraction which satisfies both? Let’s dive into LogStage and try to implement own asynchronous sink for logs.

1. LogStage - zero cost
structured logging
Maksym Ratoshniuk, 7mind.io

2. Yet another logger?

3. What is a structured
logging?

4. Common use cases:
● Tracing
● Liveness of your system
● Metrics
○ DB Calls
○ Http flow
○ Payment processing
○ Scheduling (jobs)
● Analytics
○ User behaviour
○ A/B Testing

5. Challenges

6. 1. Broken SOLID and lot’s of
magic

7. Fluentd
?

8. Scala-logging

9. Finatra

10. 2. Production unreadiness
● Asynchronous sinks
● File rotation
● Json rendering
● User context (like MDC)
● No performance hotspots

11. 3. Jar Hell

12. 3. Singletons and jar hell

13. We always write code...

14. … that is always structured

15. Logging always should be easy to read...
class ExampleService(log: IzLogger) {
val justAnArg = "example"
val justAList = List[Any](10, "green", "bottles")
log.trace(s"Argument: $justAnArg, another arg: $justAList")
log.info(s"Named expression: ${Random.nextInt() -> "random number"}")
log.warn(s"Invisible: ${Random.nextInt() -> "random number" -> null}")
val ctxLog = log("userId" -> "user@google.com", "company" -> "acme")
val delta = Random.nextInt(1000)
ctxLog.info(s"Processing time: $delta")
}

16. … and easier to deal with
class ExampleService(logger: IzLogger)
{
val justAnArg = "example"
val justAList = List[Any](
10, "green", "bottles"
)
logger.trace(
s"Argument: $justAnArg, another
arg: $justAList"
)
}

18. Features

19. Macro-based structuring and context
extraction
● Argument names, types, ordering
● Static information (file, line, class, function)
● Static part of our message - message template
(interpolation context)

20. Aliasing for references

22. Dynamic context & method
granularity

24. Reference configuration

25. SLF4J backend
A drop-in replacement for Logback, route your
legacy logs also

26. Out of box provisioning
- Console sink
- File sink
- Asynchronous sink (single worker thread at
the moment)
- String and Json rendering

27. Effectful adapters for ZIO, Cats, Monix

28. Automatic structure identifiers

29. Template as an identifier
If you have a structured
DB as a storage, you can
querying your logs with
the same structure

30. Let’s dive into coding

31. Almost no dependencies
Clean, neat, no singletons (except slf4j interop),
which may impact on working of systems with
isolated classloaders

32. Modular
Implement you own sink, router, policy, rotation

33. DI ready
Two separate settings
set.
Isn’t cool? 😍

34. DIStage out of box

35. Comparison with popular frameworks
Logstage Scribe Airframe Logback + SLF4j Scala Logging
Structured ✅ ❌ ❌ ❌ ❌
SOLID rules ✅ ❌ ❌ ❌ ❌
No singletons ✅ ❌ ❌ ❌ ❌
Modularity ✅ ❌ ❌ ❌ ❌
Asynchronous ✅ ✅ ✅ ✅ ✅
DI-readiness ✅ ❌ ❌ ❌ ❌
Colourful ✅ ❌ ✅ ✅ ❌
Dynamic Context ✅ ❌ ❌ ✅ ✅
File rotation ✅ ✅ ✅ ✅ ✅

36. Plans to work with
● Rethinking of rendering policy
● Better configuration
● Integrations with Logback, Azure,
ElasticSearch, Kafka
● Profiling and optimization performance

37. Welcome to contribution

38. Thank you for listening!
https://github.com/7mind
https://ratoshniuk.github.io/
https://github.com/ratoshniuk/scalaua-2019