1 package org
.lttng
.ust
.agent
.integration
.jul
;
3 import static org
.junit
.Assert
.assertEquals
;
4 import static org
.junit
.Assert
.assertNotNull
;
5 import static org
.junit
.Assert
.assertTrue
;
6 import static org
.junit
.Assume
.assumeTrue
;
8 import java
.io
.IOException
;
10 import java
.util
.logging
.Level
;
11 import java
.util
.logging
.Logger
;
13 import org
.junit
.After
;
14 import org
.junit
.AfterClass
;
15 import org
.junit
.Before
;
16 import org
.junit
.BeforeClass
;
17 import org
.junit
.Test
;
18 import org
.lttng
.ust
.agent
.jul
.LttngLogHandler
;
19 import org
.lttng
.ust
.agent
.utils
.LttngSessionControl
;
20 import org
.lttng
.ust
.agent
.utils
.LttngSessionControl
.Domain
;
22 public class JulEnabledEventsTest
{
24 private static final Domain DOMAIN
= Domain
.JUL
;
26 private static final String SESSION_NAME
= JulEnabledEventsTest
.class.getSimpleName();
28 private static final String EVENT_NAME_A
= "EventA";
29 private static final String EVENT_NAME_B
= "EventAB";
30 private static final String EVENT_NAME_C
= "EventABC";
31 private static final String EVENT_NAME_D
= "EventABCD";
33 private Logger loggerA
;
34 private Logger loggerB
;
35 private Logger loggerC
;
36 private Logger loggerD
;
38 private LttngLogHandler handlerA
;
39 private LttngLogHandler handlerB
;
40 private LttngLogHandler handlerC
;
43 public static void classSetup() {
44 /* Skip tests if we can't find the JNI library or lttng-tools */
46 LttngLogHandler testHandler
= new LttngLogHandler();
48 } catch (SecurityException
| IOException e
) {
52 boolean ret1
= LttngSessionControl
.setupSession(null, DOMAIN
);
53 boolean ret2
= LttngSessionControl
.stopSession(null);
54 /* "lttng view" also tests that Babeltrace is installed and working */
55 List
<String
> contents
= LttngSessionControl
.viewSession(null);
56 boolean ret3
= LttngSessionControl
.destroySession(null);
57 assumeTrue(ret1
&& ret2
&& ret3
);
58 assumeTrue(contents
.isEmpty());
62 public static void classCleanup() {
63 LttngSessionControl
.deleteAllTracee();
67 public void setup() throws SecurityException
, IOException
{
68 // TODO Wipe all existing LTTng sessions?
70 loggerA
= Logger
.getLogger(EVENT_NAME_A
);
71 loggerB
= Logger
.getLogger(EVENT_NAME_B
);
72 loggerC
= Logger
.getLogger(EVENT_NAME_C
);
73 loggerD
= Logger
.getLogger(EVENT_NAME_D
);
75 loggerA
.setLevel(Level
.ALL
);
76 loggerB
.setLevel(Level
.ALL
);
77 loggerC
.setLevel(Level
.ALL
);
78 loggerD
.setLevel(Level
.ALL
);
80 handlerA
= new LttngLogHandler();
81 handlerB
= new LttngLogHandler();
82 handlerC
= new LttngLogHandler();
84 loggerA
.addHandler(handlerA
);
85 loggerB
.addHandler(handlerB
);
86 loggerC
.addHandler(handlerC
);
90 public void teardown() {
91 /* Just in case the test failed */
92 LttngSessionControl
.tryDestroySession(SESSION_NAME
);
94 loggerA
.removeHandler(handlerA
);
95 loggerB
.removeHandler(handlerB
);
96 loggerC
.removeHandler(handlerC
);
112 * Test sending events on the Java side, but no events enabled in the
113 * tracing session. There should be nothing in the resulting trace, and
114 * handlers should not have logged anything.
117 public void testNoEvents() {
118 assertTrue(LttngSessionControl
.setupSession(SESSION_NAME
, DOMAIN
));
120 send10Events(loggerA
);
121 send10Events(loggerB
);
122 send10Events(loggerC
);
123 send10Events(loggerD
);
125 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
127 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
128 assertNotNull(output
);
129 assertTrue(output
.isEmpty());
131 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
133 assertEquals(0, handlerA
.getEventCount());
134 assertEquals(0, handlerB
.getEventCount());
135 assertEquals(0, handlerC
.getEventCount());
139 * Test sending events on the Java side, and all events enabled in the
140 * tracing session. All handlers should have sent their events.
143 public void testAllEvents() {
144 assertTrue(LttngSessionControl
.setupSessionAllEvents(SESSION_NAME
, DOMAIN
));
146 send10Events(loggerA
);
147 send10Events(loggerB
);
148 send10Events(loggerC
);
149 send10Events(loggerD
);
151 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
153 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
154 assertNotNull(output
);
155 assertEquals(30, output
.size()); // loggerD has no handler attached
157 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
159 assertEquals(10, handlerA
.getEventCount());
160 assertEquals(10, handlerB
.getEventCount());
161 assertEquals(10, handlerC
.getEventCount());
165 * Test sending events on the Java side, with only some of them enabled in
166 * the tracing session. Only the subset that is enabled should be received.
169 public void testSomeEvents() {
170 assertTrue(LttngSessionControl
.setupSession(SESSION_NAME
, DOMAIN
,
171 EVENT_NAME_A
, EVENT_NAME_C
, EVENT_NAME_D
));
173 send10Events(loggerA
);
174 send10Events(loggerB
);
175 send10Events(loggerC
);
176 send10Events(loggerD
);
178 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
180 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
181 assertNotNull(output
);
182 assertEquals(20, output
.size());
184 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
186 assertEquals(10, handlerA
.getEventCount());
187 assertEquals(0, handlerB
.getEventCount());
188 assertEquals(10, handlerC
.getEventCount());
192 * Test with all events enabled (-a), plus some other events added manually.
193 * Events should still be retained, but there should be no duplicates.
196 public void testAllEventsAndSome() {
197 assertTrue(LttngSessionControl
.setupSessionAllEvents(SESSION_NAME
, DOMAIN
));
198 assertTrue(LttngSessionControl
.enableEvents(SESSION_NAME
, DOMAIN
,
199 EVENT_NAME_A
, EVENT_NAME_B
));
201 send10Events(loggerA
);
202 send10Events(loggerB
);
203 send10Events(loggerC
);
204 send10Events(loggerD
);
206 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
208 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
209 assertNotNull(output
);
210 assertEquals(30, output
.size());
212 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
214 assertEquals(10, handlerA
.getEventCount());
215 assertEquals(10, handlerB
.getEventCount());
216 assertEquals(10, handlerC
.getEventCount());
220 * Same as {@link #testSomeEvents()}, but some events were enabled first,
221 * then disabled. Makes sure the enabled-event refcounting works properly.
224 public void testSomeEventsAfterDisabling() {
225 assertTrue(LttngSessionControl
.setupSession(SESSION_NAME
, DOMAIN
,
226 EVENT_NAME_A
, EVENT_NAME_C
, EVENT_NAME_D
));
228 assertTrue(LttngSessionControl
.disableEvents(SESSION_NAME
, DOMAIN
,
231 send10Events(loggerA
);
232 send10Events(loggerB
);
233 send10Events(loggerC
);
234 send10Events(loggerD
);
236 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
238 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
239 assertNotNull(output
);
240 assertEquals(10, output
.size());
242 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
244 assertEquals(10, handlerA
.getEventCount());
245 assertEquals(0, handlerB
.getEventCount());
246 assertEquals(0, handlerC
.getEventCount());
250 * Test enabling an event prefix, which means an event name ending with a *,
251 * to match all events starting with this name.
254 public void testEventPrefix() {
255 assertTrue(LttngSessionControl
.setupSession(SESSION_NAME
, DOMAIN
,
256 "EventAB*")); // should match event/loggers B and C, but not A.
258 send10Events(loggerA
);
259 send10Events(loggerB
);
260 send10Events(loggerC
);
261 send10Events(loggerD
);
263 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
265 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
266 assertNotNull(output
);
267 assertEquals(20, output
.size());
269 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
271 assertEquals(0, handlerA
.getEventCount());
272 assertEquals(10, handlerB
.getEventCount());
273 assertEquals(10, handlerC
.getEventCount());
277 * Same as {@link #testEventPrefix()}, but with multiple prefixes that
278 * overlap. There should not be any duplicate events in the trace or in the
282 public void testEventPrefixOverlapping() {
283 assertTrue(LttngSessionControl
.setupSession(SESSION_NAME
, DOMAIN
,
284 "EventAB*", "EventABC*")); // should still match B and C
286 send10Events(loggerA
);
287 send10Events(loggerB
);
288 send10Events(loggerC
);
289 send10Events(loggerD
);
291 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
293 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
294 assertNotNull(output
);
295 assertEquals(20, output
.size());
297 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
299 assertEquals(0, handlerA
.getEventCount());
300 assertEquals(10, handlerB
.getEventCount());
301 assertEquals(10, handlerC
.getEventCount());
305 * Test with all events enabled (-a), plus an event prefix. Once again,
306 * there should be no duplicates.
309 public void testAllEventsAndPrefix() {
310 assertTrue(LttngSessionControl
.setupSessionAllEvents(SESSION_NAME
, DOMAIN
));
311 assertTrue(LttngSessionControl
.enableEvents(SESSION_NAME
, DOMAIN
,
312 "EventAB*")); // should match B and C
314 send10Events(loggerA
);
315 send10Events(loggerB
);
316 send10Events(loggerC
);
317 send10Events(loggerD
);
319 assertTrue(LttngSessionControl
.stopSession(SESSION_NAME
));
321 List
<String
> output
= LttngSessionControl
.viewSession(SESSION_NAME
);
322 assertNotNull(output
);
323 assertEquals(30, output
.size());
325 assertTrue(LttngSessionControl
.destroySession(SESSION_NAME
));
327 assertEquals(10, handlerA
.getEventCount());
328 assertEquals(10, handlerB
.getEventCount());
329 assertEquals(10, handlerC
.getEventCount());
332 private static void send10Events(Logger logger
) {
333 String a
= new String("a");
334 Object
[] params
= { a
, new String("b"), new Object() };
336 // Levels are FINE, FINER, FINEST, INFO, SEVERE, WARNING
337 logger
.fine("A fine level message");
338 logger
.finer("A finer level message");
339 logger
.finest("A finest level message");
340 logger
.info("A info level message");
341 logger
.severe("A severe level message");
342 logger
.warning("A warning level message");
343 logger
.warning("Another warning level message");
344 logger
.log(Level
.WARNING
, "A warning message using Logger.log()");
345 logger
.log(Level
.INFO
, "A message with one parameter", a
);
346 logger
.log(Level
.INFO
, "A message with parameters", params
);