blob: 592e02aaa7e19f0c0d839b68656ca6a3cef98a50 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
package kamon
package module
import com.typesafe.config.Config
import kamon.metric.PeriodSnapshot
import kamon.trace.Span
/**
* Modules provide additional capabilities to Kamon, like collecting JVM metrics or exporting the metrics and trace
* data to external services. Additionally, modules can be automatically registered in Kamon by simply being present
* in the classpath and having the appropriate entry in the configuration file. All modules get a dedicated execution
* context which will be used to call the start, stop and reconfigure hooks.
*
* Besides the basic lifecycle hooks, when registering a [[MetricReporter]] and/or [[SpanReporter]] module, Kamon will
* also schedule calls to [[MetricReporter.reportPeriodSnapshot()]] and [[SpanReporter.reportSpans()]] in the module's
* execution context.
*/
trait Module {
/**
* Signals that a the module has been registered in Kamon's module registry.
*/
def start(): Unit
/**
* Signals that the module should be stopped and all acquired resources, if any, should be released.
*/
def stop(): Unit
/**
* Signals that a new configuration object has been provided to Kamon. Modules should ensure that their internal
* settings are in sync with the provided configuration.
*/
def reconfigure(newConfig: Config): Unit
}
/**
* Modules implementing this trait will get registered for periodically receiving metric period snapshots. The
* frequency of the period snapshots is controlled by the kamon.metric.tick-interval setting.
*/
trait MetricReporter extends Module {
def reportPeriodSnapshot(snapshot: PeriodSnapshot): Unit
}
/**
* Modules implementing this trait will get registered for periodically receiving span batches. The frequency of the
* span batches is controlled by the kamon.trace.tick-interval setting.
*/
trait SpanReporter extends Module {
def reportSpans(spans: Seq[Span.FinishedSpan]): Unit
}
/**
* Modules implementing this trait will get registered for periodically receiving metric period snapshots and span
* batches.
*/
trait CombinedReporter extends MetricReporter with SpanReporter
object Module {
sealed trait Kind
object Kind {
case object Combined extends Kind
case object Metric extends Kind
case object Span extends Kind
case object Plain extends Kind
}
/**
* Represents a module's registration on the module registry. A module can be stopped at any time by cancelling its
* registration.
*/
trait Registration {
/**
* Removes and stops the related module.
*/
def cancel(): Unit
}
/**
* Configuration of a given module present in the classpath.
*
* @param name Module's name
* @param description Module's description.
* @param clazz The class implementing the configured module.
* @param kind Module kind.
* @param enabled Whether the module is enabled or not. Enabled modules in the classpath will be automatically
* started in any call to Kamon.loadModules().
*/
case class Settings(
name: String,
description: String,
clazz: Class[_ <: Module],
kind: Module.Kind,
enabled: Boolean
)
}
|
