git.lttng.org Git - lttng-ust-java-tests.git/blob

   1 /*
   2  * Copyright (C) 2015, EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19 package org.lttng.ust.agent.integration.events;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertNotNull;
  23 import static org.junit.Assert.assertTrue;
  24 import static org.junit.Assert.fail;
  25
  26 import java.lang.reflect.Field;
  27 import java.util.Arrays;
  28 import java.util.Collections;
  29 import java.util.List;
  30
  31 import org.apache.log4j.Level;
  32 import org.apache.log4j.Logger;
  33 import org.junit.After;
  34 import org.junit.AfterClass;
  35 import org.junit.Before;
  36 import org.junit.BeforeClass;
  37 import org.junit.Test;
  38 import org.junit.runner.RunWith;
  39 import org.lttng.tools.ILttngSession;
  40 import org.lttng.tools.ILttngSession.Domain;
  41 import org.lttng.ust.agent.ILttngHandler;
  42 import org.lttng.ust.agent.LTTngAgent;
  43 import org.lttng.ust.agent.utils.Log4jTestUtils;
  44 import org.lttng.ust.agent.utils.TestPrintRunner;
  45
  46 /**
  47  * Enabled events test for the LTTng-UST Log4j log handler, using the legacy
  48  * API.
  49  */
  50 @RunWith(TestPrintRunner.class)
  51 @SuppressWarnings("deprecation")
  52 public class Log4jLegacyApiIT {
  53
  54     private static final Domain DOMAIN = Domain.LOG4J;
  55
  56     private static final String EVENT_NAME_A = "EventA";
  57     private static final String EVENT_NAME_B = "EventB";
  58
  59     private ILttngSession session;
  60     private LTTngAgent agent;
  61
  62     private Logger loggerA;
  63     private Logger loggerB;
  64
  65     /**
  66      * Class setup
  67      */
  68     @BeforeClass
  69     public static void log4jClassSetup() {
  70         Log4jTestUtils.testClassSetup();
  71     }
  72
  73     /**
  74      * Class cleanup
  75      */
  76     @AfterClass
  77     public static void log4jClassCleanup() {
  78         Log4jTestUtils.testClassCleanup();
  79     }
  80
  81     /**
  82      * Test setup
  83      */
  84     @Before
  85     public void setup() {
  86         loggerA = Logger.getLogger(EVENT_NAME_A);
  87         agent = LTTngAgent.getLTTngAgent();
  88         loggerB = Logger.getLogger(EVENT_NAME_B);
  89
  90         loggerA.setLevel(Level.ALL);
  91         loggerB.setLevel(Level.ALL);
  92
  93         session = ILttngSession.createSession(null, DOMAIN);
  94     }
  95
  96     /**
  97      * Test cleanup
  98      */
  99     @After
 100     public void tearDown() {
 101         session.close();
 102
 103         agent.dispose();
 104
 105         loggerA = null;
 106         loggerB = null;
 107     }
 108
 109     /**
 110      * Test tracing with no events enabled in the tracing session.
 111      */
 112     @Test
 113     public void testNoEvents() {
 114         assertTrue(session.start());
 115
 116         Log4jTestUtils.send10Events(loggerA);
 117         Log4jTestUtils.send10Events(loggerB);
 118
 119         assertTrue(session.stop());
 120
 121         List<String> output = session.view();
 122         assertNotNull(output);
 123         assertTrue(output.isEmpty());
 124
 125         ILttngHandler handler = getAgentHandler();
 126         assertEquals(0, handler.getEventCount());
 127     }
 128
 129     /**
 130      * Test tracing with all events enabled (-l -a) in the tracing session.
 131      */
 132     @Test
 133     public void testAllEvents() {
 134         assertTrue(session.enableAllEvents());
 135         assertTrue(session.start());
 136
 137         Log4jTestUtils.send10Events(loggerA);
 138         Log4jTestUtils.send10Events(loggerB);
 139
 140         assertTrue(session.stop());
 141
 142         List<String> output = session.view();
 143         assertNotNull(output);
 144         assertEquals(20, output.size());
 145
 146         ILttngHandler handler = getAgentHandler();
 147         assertEquals(20, handler.getEventCount());
 148     }
 149
 150     /**
 151      * Test tracing with a subset of events enabled in the tracing session.
 152      */
 153     @Test
 154     public void testSomeEvents() {
 155         assertTrue(session.enableEvents(EVENT_NAME_A));
 156         assertTrue(session.start());
 157
 158         Log4jTestUtils.send10Events(loggerA);
 159         Log4jTestUtils.send10Events(loggerB);
 160
 161         assertTrue(session.stop());
 162
 163         List<String> output = session.view();
 164         assertNotNull(output);
 165         assertEquals(10, output.size());
 166
 167         ILttngHandler handler = getAgentHandler();
 168         assertEquals(10, handler.getEventCount());
 169     }
 170
 171     /**
 172      * Test that the "lttng list" commands lists the expected events.
 173      */
 174     @Test
 175     public void testListEvents() {
 176         List<String> enabledEvents = session.listEvents();
 177         List<String> expectedEvents = Arrays.asList(EVENT_NAME_A, EVENT_NAME_B);
 178
 179         Collections.sort(enabledEvents);
 180         Collections.sort(expectedEvents);
 181
 182         assertEquals(expectedEvents, enabledEvents);
 183     }
 184
 185     /**
 186      * Get the singleton Log4j Handler currently managed by the LTTngAgent. It
 187      * is not public, so we need reflection to access it.
 188      *
 189      * @return The agent's Log4j handler
 190      */
 191     private static ILttngHandler getAgentHandler() {
 192         try {
 193             Field log4jAppenderField = LTTngAgent.class.getDeclaredField("log4jAppender");
 194             log4jAppenderField.setAccessible(true);
 195             return (ILttngHandler) log4jAppenderField.get(LTTngAgent.getLTTngAgent());
 196         } catch (ReflectiveOperationException | SecurityException e) {
 197             fail(e.getMessage());
 198             return null;
 199         }
 200     }
 201
 202 }
 203