/*
* =========================================================================================
* Copyright © 2013-2016 the kamon project <http://kamon.io/>
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the
* License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
* =========================================================================================
*/
package kamon.trace
import java.util.concurrent.ConcurrentLinkedQueue
import akka.event.LoggingAdapter
import kamon.Kamon
import kamon.metric.{SegmentMetrics, TraceMetrics}
import kamon.util.{NanoInterval, RelativeNanoTimestamp}
import scala.annotation.tailrec
import scala.collection.concurrent.TrieMap
private[kamon] class MetricsOnlyContext(
traceName: String,
val token: String,
traceTags: Map[String, String],
currentStatus: Status,
val levelOfDetail: LevelOfDetail,
val startTimestamp: RelativeNanoTimestamp,
log: LoggingAdapter
) extends TraceContext {
@volatile private var _name = traceName
@volatile private var _status = currentStatus
@volatile protected var _elapsedTime = NanoInterval.default
private val _finishedSegments = new ConcurrentLinkedQueue[SegmentLatencyData]()
private val _traceLocalStorage = new TraceLocalStorage
private val _tags = TrieMap.empty[String, String] ++= traceTags
def rename(newName: String): Unit =
if (Status.Open == status)
_name = newName
else
log.warning("Can't rename trace from [{}] to [{}] because the trace is already closed.", name, newName)
def name: String = _name
def tags: Map[String, String] = _tags.toMap
def isEmpty: Boolean = false
def status: Status = _status
def addMetadata(key: String, value: String): Unit = {}
def addTag(key: String, value: String): Unit = _tags.put(key, value)
def removeTag(key: String, value: String): Boolean = _tags.remove(key, value)
private def finish(withError: Boolean): Unit = {
_status = if (withError) Status.FinishedWithError else Status.FinishedSuccessfully
val traceElapsedTime = NanoInterval.since(startTimestamp)
_elapsedTime = traceElapsedTime
if (Kamon.metrics.shouldTrack(name, TraceMetrics.category)) {
val traceEntity = Kamon.metrics.entity(TraceMetrics, name, _tags.toMap)
traceEntity.elapsedTime.record(traceElapsedTime.nanos)
if (withError) traceEntity.errors.increment()
}
drainFinishedSegments()
}
def finish(): Unit = finish(withError = false)
def finishWithError(cause: Throwable): Unit = {
//we should do something with the Throwable in a near future
finish(withError = true)
}
def startSegment(segmentName: String, category: String, library: String): Segment =
startSegment(segmentName, category, library, Map.empty[String, String])
def startSegment(segmentName: String, category: String, library: String, tags: Map[String, String]): Segment =
new MetricsOnlySegment(segmentName, category, library, tags)
@tailrec private def drainFinishedSegments(): Unit = {
val segment = _finishedSegments.poll()
if (segment != null) {
val defaultTags = Map(
"trace" → name,
"category" → segment.category,
"library" → segment.library
)
if (Kamon.metrics.shouldTrack(segment.name, SegmentMetrics.category)) {
val segmentEntity = Kamon.metrics.entity(SegmentMetrics, segment.name, defaultTags ++ segment.tags)
segmentEntity.elapsedTime.record(segment.duration.nanos)
if (segment.isFinishedWithError) segmentEntity.errors.increment()
}
drainFinishedSegments()
}
}
protected def finishSegment(
segmentName: String,
category: String,
library: String,
duration: NanoInterval,
segmentTags: Map[String, String],
isFinishedWithError: Boolean
): Unit = {
_finishedSegments.add(SegmentLatencyData(segmentName, category, library, duration, segmentTags, isFinishedWithError))
if (isClosed) {
drainFinishedSegments()
}
}
// Should only be used by the TraceLocal utilities.
def traceLocalStorage: TraceLocalStorage = _traceLocalStorage
// Handle with care and make sure that the trace is closed before calling this method, otherwise NanoInterval.default
// will be returned.
def elapsedTime: NanoInterval = _elapsedTime
class MetricsOnlySegment(
segmentName: String,
val category: String,
val library: String,
segmentTags: Map[String, String]
) extends Segment {
private val _startTimestamp = RelativeNanoTimestamp.now
private val _tags = TrieMap.empty[String, String] ++= segmentTags
@volatile private var _segmentName = segmentName
@volatile private var _elapsedTime = NanoInterval.default
@volatile private var _status: Status = Status.Open
def name: String = _segmentName
def tags: Map[String, String] = _tags.toMap
def isEmpty: Boolean = false
def status: Status = _status
def addMetadata(key: String, value: String): Unit = {}
def addTag(key: String, value: String): Unit = _tags.put(key, value)
def removeTag(key: String, value: String): Boolean = _tags.remove(key, value)
def rename(newName: String): Unit =
if (Status.Open == status)
_segmentName = newName
else
log.warning("Can't rename segment from [{}] to [{}] because the segment is already closed.", name, newName)
private def finish(withError: Boolean): Unit = {
_status = if (withError) Status.FinishedWithError else Status.FinishedSuccessfully
val segmentElapsedTime = NanoInterval.since(_startTimestamp)
_elapsedTime = segmentElapsedTime
finishSegment(name, category, library, segmentElapsedTime, _tags.toMap, withError)
}
def finishWithError(cause: Throwable): Unit = {
//we should do something with the Throwable in a near future
finish(withError = true)
}
def finish(): Unit = finish(withError = false)
// Handle with care and make sure that the segment is closed before calling this method, otherwise
// NanoInterval.default will be returned.
def elapsedTime: NanoInterval = _elapsedTime
def startTimestamp: RelativeNanoTimestamp = _startTimestamp
}
}
case class SegmentLatencyData(
name: String,
category: String,
library: String,
duration: NanoInterval,
tags: Map[String, String],
isFinishedWithError: Boolean
)