private void writeSDKInfoFile() { String sdkInfoFilePath = String.format("%s/%s", Constants.AI_SDK_DIRECTORY, Constants.AI_SDK_INFO_FILENAME); String instrumentationKey = TelemetryConfiguration.getActive().getInstrumentationKey(); String sdkInfo = String.format(Constants.AI_SDK_INFO_FILE_CONTENT_TEMPLATE, instrumentationKey); try { fileFactory.create(sdkInfoFilePath, sdkInfo); } catch (IOException e) { InternalLogger.INSTANCE.error("Failed to write SDK info file for Docker awareness. Error: %s", e.toString()); } } }
@Bean @DependsOn("internalLogger") public TelemetryConfiguration telemetryConfiguration(TelemetryChannel telemetryChannel) { TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.getActiveWithoutInitializingConfig(); telemetryConfiguration.setTrackingIsDisabled(!applicationInsightsProperties.isEnabled()); telemetryConfiguration.setInstrumentationKey(applicationInsightsProperties.getInstrumentationKey()); if (contextInitializers != null) { telemetryConfiguration.getContextInitializers().addAll(contextInitializers); } if (telemetryInitializers != null) { telemetryConfiguration.getTelemetryInitializers().addAll(telemetryInitializers); } if (telemetryModules != null) { telemetryConfiguration.getTelemetryModules().addAll(telemetryModules); } if (telemetryProcessors != null) { telemetryConfiguration.getTelemetryProcessors().addAll(telemetryProcessors); } telemetryConfiguration.setChannel(telemetryChannel); initializeComponents(telemetryConfiguration); initializePerformanceCounterContainer(); return telemetryConfiguration; }
boolean isDeveloperMode = StringUtils.equalsIgnoreCase(isDeveloperModeProperty, "true"); ContextInitializer initializer = new TelemetryContextInitializer(isDeveloperMode); TelemetryConfiguration.getActive().getContextInitializers().add(initializer); final TelemetryChannel channel = TelemetryConfiguration.getActive().getChannel(); if (channel != null) { channel.setDeveloperMode(isDeveloperMode);
@Bean @ConditionalOnMissingBean public TelemetryConfiguration telemetryConfiguration(AzureMonitorConfig config) { // Gets the active instance of TelemetryConfiguration either created by starter or xml TelemetryConfiguration telemetryConfiguration = TelemetryConfiguration.getActive(); if (StringUtils.isEmpty(telemetryConfiguration.getInstrumentationKey())) { telemetryConfiguration.setInstrumentationKey(config.instrumentationKey()); } return telemetryConfiguration; }
private static WebRequestTrackingTelemetryModule getCurrentWebRequestTrackingModule() { List<TelemetryModule> modules = TelemetryConfiguration.getActive().getTelemetryModules(); for (TelemetryModule module : modules) { if (module instanceof WebRequestTrackingTelemetryModule) { return (WebRequestTrackingTelemetryModule) module; } } return null; }
@Test public void testInitializeAllDefaults() throws Exception { AppInsightsConfigurationBuilder mockParser = createMockParser(true, true, false); ApplicationInsightsXmlConfiguration appConf = mockParser.build(null); appConf.setInstrumentationKey(MOCK_IKEY); TelemetryConfiguration mockConfiguration = new TelemetryConfiguration(); initializeWithFactory(mockParser, mockConfiguration); assertEquals(false, mockConfiguration.isTrackingDisabled()); assertEquals(MOCK_IKEY, mockConfiguration.getInstrumentationKey()); assertThat(mockConfiguration.getContextInitializers(), Matchers.<ContextInitializer>hasSize(3)); assertThat(mockConfiguration.getTelemetryInitializers(), Matchers.<TelemetryInitializer>empty()); assertThat(mockConfiguration.getTelemetryProcessors(), empty()); assertThat(mockConfiguration.getChannel(), instanceOf(StdOutChannel.class)); }
@BeforeClass public static void classInitialize() throws Exception { server.start(); // Set mock channel channel = MockTelemetryChannel.INSTANCE; TelemetryConfiguration.getActive().setChannel(channel); TelemetryConfiguration.getActive().setInstrumentationKey("SOME_INT_KEY"); }
@Test public void testEmptyConfiguration() { TelemetryConfiguration emptyConfig = TelemetryConfiguration.getActiveWithoutInitializingConfig(); Assert.assertNull(emptyConfig.getInstrumentationKey()); Assert.assertSame(NopTelemetryChannel.instance(), emptyConfig.getChannel()); Assert.assertEquals(0, emptyConfig.getTelemetryModules().size()); Assert.assertFalse(emptyConfig.isTrackingDisabled()); Assert.assertEquals(0, emptyConfig.getContextInitializers().size()); Assert.assertEquals(0, emptyConfig.getTelemetryProcessors().size()); }
@Test public void shouldHaveIdenticalConfiguration() throws Exception{ Field field = telemetryClient.getClass().getDeclaredField("configuration"); field.setAccessible(true); TelemetryConfiguration config1 = (TelemetryConfiguration)field.get(telemetryClient); //needed for clearing down the active instance and get the new config. tearDown(); //Instance created from XML config. TelemetryClient t2 = new TelemetryClient(); Field field2 = t2.getClass().getDeclaredField("configuration"); field2.setAccessible(true); TelemetryConfiguration config2 = (TelemetryConfiguration)field2.get(t2); Assert.assertNotEquals(config1, config2); //There is one additional TelemetryInitializer in case of SpringBoot(For Cloud_RoleName) Assert.assertEquals(config1.getTelemetryInitializers().size(), config2.getTelemetryInitializers().size() + 1); Assert.assertEquals(config1.getTelemetryModules().size(), config2.getTelemetryModules().size()); Assert.assertEquals(config1.getContextInitializers().size(), config2.getContextInitializers().size()); Assert.assertEquals(config1.getTelemetryProcessors().size(), config2.getTelemetryProcessors().size()); Assert.assertEquals(config1.getInstrumentationKey(), config2.getInstrumentationKey()); Assert.assertEquals(config1.isTrackingDisabled(), config2.isTrackingDisabled()); }
/** * Initializes a new instance of the TelemetryClient class, configured from the active configuration. */ public TelemetryClient() { this(TelemetryConfiguration.getActive()); }
@Test public void testWithEmptySections() { AppInsightsConfigurationBuilder mockParser = Mockito.mock(AppInsightsConfigurationBuilder.class); ApplicationInsightsXmlConfiguration appConf = new ApplicationInsightsXmlConfiguration(); appConf.setInstrumentationKey(MOCK_IKEY); appConf.setTelemetryInitializers(null); appConf.setContextInitializers(null); appConf.setModules(null); appConf.setSdkLogger(null); Mockito.doReturn(appConf).when(mockParser).build(any(InputStream.class)); TelemetryConfiguration mockConfiguration = new TelemetryConfiguration(); initializeWithFactory(mockParser, mockConfiguration); assertEquals(false, mockConfiguration.isTrackingDisabled()); assertEquals(MOCK_IKEY, mockConfiguration.getInstrumentationKey()); assertThat(mockConfiguration.getContextInitializers(), hasSize(3)); assertThat(mockConfiguration.getChannel(), instanceOf(InProcessTelemetryChannel.class)); }
private TelemetryConfiguration createConfiguration(final List<Telemetry> itemsToSend) { TelemetryConfiguration configuration = new TelemetryConfiguration(); configuration.setInstrumentationKey("00000000-0000-0000-0000-000000000000"); class StubBufferTelemetryChannel extends StubTelemetryChannel { @Override public void send(Telemetry item) { itemsToSend.add(item); //item.reset(); } } configuration.setChannel(new StubBufferTelemetryChannel()); return configuration; }
@Test public void shouldBeAbleToAddCustomModules() { EnvironmentTestUtils.addEnvironment(context, "azure.application-insights.instrumentation-key: 00000000-0000-0000-0000-000000000000"); context.register(PropertyPlaceholderAutoConfiguration.class, ApplicationInsightsTelemetryAutoConfiguration.class, CustomModuleConfiguration.class); context.refresh(); TelemetryConfiguration telemetryConfiguration = context.getBean(TelemetryConfiguration.class); ContextInitializer myContextInitializer = context.getBean("myContextInitializer", ContextInitializer.class); TelemetryInitializer myTelemetryInitializer = context.getBean("myTelemetryInitializer", TelemetryInitializer.class); TelemetryModule myTelemetryModule = context.getBean("myTelemetryModule", TelemetryModule.class); TelemetryProcessor myTelemetryProcessor = context.getBean("myTelemetryProcessor", TelemetryProcessor.class); assertThat(telemetryConfiguration.getContextInitializers()).contains(myContextInitializer); assertThat(telemetryConfiguration.getTelemetryInitializers()).contains(myTelemetryInitializer); assertThat(telemetryConfiguration.getTelemetryModules()).contains(myTelemetryModule); assertThat(telemetryConfiguration.getTelemetryProcessors()).contains(myTelemetryProcessor); }
public static void main(String[] args) throws IOException { System.out.println("This program sends application insights telemetry event using custom context initializer."); TelemetryClient appInsights = new TelemetryClient(); if (args.length > 0) { appInsights.getContext().setInstrumentationKey(args[0]); } appInsights.getContext().setInstrumentationKey("your-ikey"); String iKey = appInsights.getContext().getInstrumentationKey(); if (iKey == null) { System.out.println("Error: no iKey set in ApplicationInsights.xml or as a parameter for this program."); return; } GitBuildInfoContextInitializer customContextInitializer = new GitBuildInfoContextInitializer(); TelemetryConfiguration.getActive().getContextInitializers().add(customContextInitializer); System.out.println("Custom context initializer added to configuration"); // Trace telemetry appInsights.trackTrace("Things seem to be going well"); System.out.println("[3] Trace -- text=\"Things seem to be going well\""); System.out.println(); System.out.println("Press any key to exit"); System.in.read(); }
@Test public void testNewSessionCookieIsNotCreatedWhenCookieNotExist() throws Exception { TelemetryConfiguration.getActive().getTelemetryInitializers().add(new TestModuleInitializer(null, false)); CookiesContainer cookiesContainer = HttpHelper.sendRequestAndGetResponseCookie(server.getPortNumber()); Assert.assertNull("Session cookie should be null.", cookiesContainer.getSessionCookie()); }
TelemetryConfiguration.getActive().getChannel().setDeveloperMode(true);
@Test public void testInitializeWithFailingParse() throws Exception { AppInsightsConfigurationBuilder mockParser = createMockParserThatFailsToParse(); TelemetryConfiguration mockConfiguration = new TelemetryConfiguration(); initializeWithFactory(mockParser, mockConfiguration); assertEquals(false, mockConfiguration.isTrackingDisabled()); assertThat(mockConfiguration.getChannel(), instanceOf(InProcessTelemetryChannel.class)); }
private void ikeyTest(String configurationIkey, String expectedIkey) { // Make sure that there is no exception when fetching the i-key by having both // the i-key and channel in the configuration, otherwise the channel won't be instantiated AppInsightsConfigurationBuilder mockParser = createMockParser(true, false, false); ApplicationInsightsXmlConfiguration appConf = new ApplicationInsightsXmlConfiguration(); appConf.setInstrumentationKey(configurationIkey); Mockito.doReturn(appConf).when(mockParser).build(any(InputStream.class)); TelemetryConfiguration mockConfiguration = new TelemetryConfiguration(); initializeWithFactory(mockParser, mockConfiguration); assertEquals(mockConfiguration.getInstrumentationKey(), expectedIkey); assertTrue(mockConfiguration.getChannel() instanceof InProcessTelemetryChannel); }
TelemetryConfiguration.getActive().setInstrumentationKey("myOtherIkey");
private TelemetryContext createInitializedContext() { TelemetryContext ctx = new TelemetryContext(); ctx.setInstrumentationKey(configuration.getInstrumentationKey()); for (ContextInitializer init : configuration.getContextInitializers()) { try { init.initialize(ctx); } catch (ThreadDeath td) { throw td; } catch (Throwable t) { try { InternalLogger.INSTANCE.error("Exception in context initializer: '%s'", t.toString()); } catch (ThreadDeath td) { throw td; } catch (Throwable t2) { // chomp } } } // Set the nodeName for billing purpose if it does not already exist InternalContext internal = ctx.getInternal(); if (CommonUtils.isNullOrEmpty(internal.getNodeName())) { String host = CommonUtils.getHostName(); if (!CommonUtils.isNullOrEmpty(host)) { internal.setNodeName(host); } } return ctx; } }