aboutsummaryrefslogtreecommitdiff
path: root/kamon-status-page/src/main/scala/kamon/status/page/JsonMarshalling.scala
blob: 0a66fcacc9cd508d72d26b4d631d2404711af10d (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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
package kamon.status.page

import java.lang.{StringBuilder => JavaStringBuilder}

import com.grack.nanojson.JsonWriter
import com.typesafe.config.ConfigRenderOptions
import kamon.module.Module
import kamon.status.Status

import scala.collection.JavaConverters.{iterableAsScalaIterableConverter, mapAsScalaMapConverter}


trait JsonMarshalling[T] {

  /**
    * Implementations should append a Json object or array that describes the given instance members and any
    * additional information that is expected to be shown in the status mini site.
    */
  def toJson(instance: T, builder: JavaStringBuilder): Unit
}

object JsonMarshalling {

  implicit object ModuleRegistryStatusJsonMarshalling extends JsonMarshalling[Status.ModuleRegistry] {
    override def toJson(instance: Status.ModuleRegistry, builder: JavaStringBuilder): Unit = {
      def moduleKindString(moduleKind: Module.Kind): String = moduleKind match {
        case Module.Kind.Combined => "combined"
        case Module.Kind.Metric   => "metric"
        case Module.Kind.Span     => "span"
        case Module.Kind.Plain    => "plain"
      }

      val array = JsonWriter.on(builder)
        .`object`()
        .array("modules")

      instance.modules.foreach(m => {
        array.`object`()
          .value("name", m.name)
          .value("description", m.description)
          .value("clazz", m.clazz)
          .value("kind", moduleKindString(m.kind))
          .value("programmaticallyRegistered", m.programmaticallyRegistered)
          .value("enabled", m.enabled)
          .value("started", m.started)
          .end()
      })

      array.end().end().done()
    }
  }

  implicit object BaseInfoJsonMarshalling extends JsonMarshalling[Status.Settings] {
    override def toJson(instance: Status.Settings, builder: JavaStringBuilder): Unit = {
      val baseConfigJson = JsonWriter.on(builder)
        .`object`()
          .value("version", instance.version)
          .value("config", instance.config.root().render(ConfigRenderOptions.concise()))

      baseConfigJson.`object`("environment")
        .value("service", instance.environment.service)
        .value("host", instance.environment.host)
        .value("instance", instance.environment.instance)
        .`object`("tags")

      instance.environment.tags.foreach {
        case (key, value) => baseConfigJson.value(key, value)
      }

      baseConfigJson
        .end() // ends tags
        .end() // ends environment
        .end() // ends base config
        .done()
    }
  }

  implicit object MetricRegistryStatusJsonMarshalling extends JsonMarshalling[Status.MetricRegistry] {
    override def toJson(instance: Status.MetricRegistry, builder: JavaStringBuilder): Unit = {
      val metricsObject = JsonWriter.on(builder)
        .`object`
          .array("metrics")

      instance.metrics.foreach(metric => {
        metricsObject
          .`object`()
            .value("name", metric.name)
            .value("type", metric.instrumentType.name)
            .value("unitDimension", metric.unit.dimension.name)
            .value("unitMagnitude", metric.unit.magnitude.name)
            .`object`("tags")

        metric.tags.foreach { case (tag, value) => metricsObject.value(tag, value) }

        metricsObject
          .end() // tags
          .end() // metric info
      })

      metricsObject
        .end() // metrics array
        .end() // object
        .done()
    }
  }

  implicit object InstrumentationStatusJsonMarshalling extends JsonMarshalling[Status.Instrumentation] {
    override def toJson(instance: Status.Instrumentation, builder: JavaStringBuilder): Unit = {
      val instrumentationObject = JsonWriter.on(builder)
        .`object`()
          .value("active", instance.active)
          .`object`("modules")

      instance.modules.asScala.foreach {
        case (moduleName, moduleDescription) => instrumentationObject.value(moduleName, moduleDescription)
      }

      instrumentationObject
        .end() // end modules
        .`object`("errors")

      instance.errors.asScala.foreach {
        case (moduleName, errors) =>
          instrumentationObject.array(moduleName)
          errors.asScala.foreach(t => instrumentationObject.value(t.toString))
          instrumentationObject.end()
      }

      instrumentationObject
        .end() // errors
        .end() // object
        .done()
    }
  }
}