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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/* =========================================================================================
* Copyright © 2013-2014 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.jdbc.instrumentation
import java.sql.{ DriverManager, SQLException }
import com.typesafe.config.ConfigFactory
import kamon.jdbc.{ Jdbc, JdbcNameGenerator, SqlErrorProcessor, SlowQueryProcessor }
import kamon.metric.TraceMetricsSpec
import kamon.testkit.BaseKamonSpec
import kamon.trace.{ SegmentCategory, TraceContext }
class StatementInstrumentationSpec extends BaseKamonSpec("jdbc-spec") {
import TraceMetricsSpec.SegmentSyntax
override lazy val config =
ConfigFactory.parseString(
"""
|kamon {
| jdbc {
| slow-query-threshold = 100 milliseconds
|
| # Fully qualified name of the implementation of kamon.jdbc.SlowQueryProcessor.
| slow-query-processor = kamon.jdbc.instrumentation.NoOpSlowQueryProcessor
|
| # Fully qualified name of the implementation of kamon.jdbc.SqlErrorProcessor.
| sql-error-processor = kamon.jdbc.instrumentation.NoOpSqlErrorProcessor
|
| # Fully qualified name of the implementation of kamon.jdbc.JdbcNameGenerator
| name-generator = kamon.jdbc.instrumentation.NoOpJdbcNameGenerator
| }
|}
""".stripMargin)
val connection = DriverManager.getConnection("jdbc:h2:mem:jdbc-spec", "SA", "")
override protected def beforeAll(): Unit = {
connection should not be null
val create = "CREATE TABLE Address (Nr INTEGER, Name VARCHAR(128));"
val createStatement = connection.createStatement()
createStatement.executeUpdate(create)
val sleep = "CREATE ALIAS SLEEP FOR \"java.lang.Thread.sleep(long)\""
val sleepStatement = connection.createStatement()
sleepStatement.executeUpdate(sleep)
}
"the StatementInstrumentation" should {
"record the execution time of INSERT operation" in {
TraceContext.withContext(newContext("jdbc-trace-insert")) {
for (id ← 1 to 100) {
val insert = s"INSERT INTO Address (Nr, Name) VALUES($id, 'foo')"
val insertStatement = connection.prepareStatement(insert)
insertStatement.execute()
}
TraceContext.currentContext.finish()
}
val jdbcSnapshot = takeSnapshotOf("jdbc-statements", "jdbc-statements")
jdbcSnapshot.histogram("writes").get.numberOfMeasurements should be(100)
val traceSnapshot = takeSnapshotOf("jdbc-trace-insert", "trace")
traceSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
traceSnapshot.segments.size should be(1)
traceSnapshot.segment("Jdbc[Insert]", SegmentCategory.Database, Jdbc.SegmentLibraryName).numberOfMeasurements should be(100)
}
"record the execution time of SELECT operation" in {
TraceContext.withContext(newContext("jdbc-trace-select")) {
for (id ← 1 to 100) {
val select = s"SELECT * FROM Address where Nr = $id"
val selectStatement = connection.createStatement()
selectStatement.execute(select)
}
TraceContext.currentContext.finish()
}
val jdbcSnapshot = takeSnapshotOf("jdbc-statements", "jdbc-statements")
jdbcSnapshot.histogram("reads").get.numberOfMeasurements should be(100)
val traceSnapshot = takeSnapshotOf("jdbc-trace-select", "trace")
traceSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
traceSnapshot.segments.size should be(1)
traceSnapshot.segment("Jdbc[Select]", SegmentCategory.Database, Jdbc.SegmentLibraryName).numberOfMeasurements should be(100)
}
"record the execution time of UPDATE operation" in {
TraceContext.withContext(newContext("jdbc-trace-update")) {
for (id ← 1 to 100) {
val update = s"UPDATE Address SET Name = 'bar$id' where Nr = $id"
val updateStatement = connection.prepareStatement(update)
updateStatement.execute()
}
TraceContext.currentContext.finish()
}
val jdbcSnapshot = takeSnapshotOf("jdbc-statements", "jdbc-statements")
jdbcSnapshot.histogram("writes").get.numberOfMeasurements should be(100)
val traceSnapshot = takeSnapshotOf("jdbc-trace-update", "trace")
traceSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
traceSnapshot.segments.size should be(1)
traceSnapshot.segment("Jdbc[Update]", SegmentCategory.Database, Jdbc.SegmentLibraryName).numberOfMeasurements should be(100)
}
"record the execution time of DELETE operation" in {
TraceContext.withContext(newContext("jdbc-trace-delete")) {
for (id ← 1 to 100) {
val delete = s"DELETE FROM Address where Nr = $id"
val deleteStatement = connection.createStatement()
deleteStatement.execute(delete)
}
TraceContext.currentContext.finish()
}
val jdbcSnapshot = takeSnapshotOf("jdbc-statements", "jdbc-statements")
jdbcSnapshot.histogram("writes").get.numberOfMeasurements should be(100)
val traceSnapshot = takeSnapshotOf("jdbc-trace-delete", "trace")
traceSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
traceSnapshot.segments.size should be(1)
traceSnapshot.segment("Jdbc[Delete]", SegmentCategory.Database, Jdbc.SegmentLibraryName).numberOfMeasurements should be(100)
}
"record the execution time of SLOW QUERIES based on the kamon.jdbc.slow-query-threshold" in {
TraceContext.withContext(newContext("jdbc-trace-slow")) {
for (id ← 1 to 2) {
val select = s"SELECT * FROM Address; CALL SLEEP(100)"
val selectStatement = connection.createStatement()
selectStatement.execute(select)
}
TraceContext.currentContext.finish()
}
val jdbcSnapshot = takeSnapshotOf("jdbc-statements", "jdbc-statements")
jdbcSnapshot.counter("slows").get.count should be(2)
}
"count all SQL ERRORS" in {
TraceContext.withContext(newContext("jdbc-trace-errors")) {
for (_ ← 1 to 10) {
intercept[SQLException] {
val error = "SELECT * FROM NO_EXISTENT_TABLE"
val errorStatement = connection.createStatement()
errorStatement.execute(error)
}
}
TraceContext.currentContext.finish()
}
val jdbcSnapshot = takeSnapshotOf("jdbc-statements", "jdbc-statements")
jdbcSnapshot.counter("errors").get.count should be(10)
}
}
}
class NoOpSlowQueryProcessor extends SlowQueryProcessor {
override def process(sql: String, executionTimeInMillis: Long, queryThresholdInMillis: Long): Unit = { /*do nothing!!!*/ }
}
class NoOpSqlErrorProcessor extends SqlErrorProcessor {
override def process(sql: String, ex: Throwable): Unit = { /*do nothing!!!*/ }
}
class NoOpJdbcNameGenerator extends JdbcNameGenerator {
override def generateJdbcSegmentName(statement: String): String = s"Jdbc[$statement]"
}
|
