WEBVTT

0:00:03.000000 --> 0:00:10.980000
 For this video, I'm going to attempt
 to be controlled and not completely

0:00:10.980000 --> 0:00:16.320000
 geek out because application insights
 is one of my favorite topics in

0:00:16.320000 --> 0:00:21.060000
 Azure. Just it's so powerful and it gives
 you so much as a developer that

0:00:21.060000 --> 0:00:22.480000
 I like talking about it.

0:00:22.480000 --> 0:00:27.120000
 But this is not a development class,
 so I'm going to not go as deep dive

0:00:27.120000 --> 0:00:28.980000
 as I might possibly want.

0:00:28.980000 --> 0:00:32.620000
 But we're still going to talk about
 it a bit because a if you're going

0:00:32.620000 --> 0:00:34.840000
 to work in Azure, if you're going to
 take the exam, you're responsible

0:00:34.840000 --> 0:00:40.060000
 for it. But also I think just in general
 that it's a really important

0:00:40.060000 --> 0:00:43.480000
 topic. So what we're going to cover,
 we're going to look at application

0:00:43.480000 --> 0:00:47.640000
 monitoring kind of what you need to think
 about with application monitoring.

0:00:47.640000 --> 0:00:51.740000
 Then we'll look at what application
 insights gives you.

0:00:51.740000 --> 0:00:57.160000
 We'll look at application insights
 to limit tree what it collects.

0:00:57.160000 --> 0:01:00.820000
 We'll also talk about the reports that
 are built into application insights

0:01:00.820000 --> 0:01:02.720000
 that you can take a look at.

0:01:02.720000 --> 0:01:06.680000
 And we'll talk about how you can integrate
 application insights into your

0:01:06.680000 --> 0:01:12.280000
 application and then we'll round out with
 a brief demonstration of application

0:01:12.280000 --> 0:01:16.640000
 insights. Again, not to go too deep
 down that all because this could be

0:01:16.640000 --> 0:01:20.160000
 a two hour video and that would
 probably put you to sleep.

0:01:20.160000 --> 0:01:21.600000
 So let's not do that.

0:01:21.600000 --> 0:01:24.820000
 Alright, let's start out talking
 about application monitoring.

0:01:24.820000 --> 0:01:27.500000
 Now if we think about application monitoring
 and we think about monitoring

0:01:27.500000 --> 0:01:30.820000
 in general, I think we're probably all
 pretty familiar with monitoring.

0:01:30.820000 --> 0:01:32.120000
 Let's take an example.

0:01:32.120000 --> 0:01:34.120000
 We've got a virtual machine here.

0:01:34.120000 --> 0:01:40.000000
 Okay, that virtual machine is running
 in Azure and it's communicating

0:01:40.000000 --> 0:01:43.880000
 some telemetry back to Azure.

0:01:43.880000 --> 0:01:48.100000
 And that's going to be probably
 your system level telemetry.

0:01:48.100000 --> 0:01:55.220000
 So we have things like probably
 our, you know, VCP usage.

0:01:55.220000 --> 0:02:05.140000
 We have things like memory usage and
 we can get extended telemetry.

0:02:05.140000 --> 0:02:10.740000
 We can drop that telemetry into let's
 say log analytics and we can do

0:02:10.740000 --> 0:02:13.400000
 things like events.

0:02:13.400000 --> 0:02:18.840000
 And so we get that, but that's all kind
 of at the host level, if you will.

0:02:18.840000 --> 0:02:21.920000
 But if you think about, let's say even
 in the case of this virtual machine

0:02:21.920000 --> 0:02:25.700000
 or let's say a web app, let's say
 I've got a web app down here.

0:02:25.700000 --> 0:02:31.520000
 And WA for web app, right?

0:02:31.520000 --> 0:02:36.360000
 And I've got some code running
 in this web app.

0:02:36.360000 --> 0:02:41.540000
 Right? And so now I might be interested
 in things like, you know, what

0:02:41.540000 --> 0:02:44.880000
 are the response times?

0:02:44.880000 --> 0:02:53.680000
 What's the overall
 app architecture?

0:02:53.680000 --> 0:02:55.840000
 So what are the components
 that are communicating?

0:02:55.840000 --> 0:02:57.740000
 And how are they communicating?

0:02:57.740000 --> 0:03:03.140000
 I might want some, you know,
 detailed error messages.

0:03:03.140000 --> 0:03:05.940000
 I might want to be
 able to test it.

0:03:05.940000 --> 0:03:11.000000
 Might be able to, I might want to see things
 maybe even some custom telemetry.

0:03:11.000000 --> 0:03:15.120000
 Right? But I have all of these needs
 that really go beyond just, hey,

0:03:15.120000 --> 0:03:16.660000
 is that web app up and running?

0:03:16.660000 --> 0:03:18.580000
 What's my CPU percentage?

0:03:18.580000 --> 0:03:23.120000
 I have all of these things that
 I would like to record.

0:03:23.120000 --> 0:03:29.860000
 Right? And that is where application
 insights comes into play.

0:03:29.860000 --> 0:03:38.920000
 It gives us this powerful telemetry
 collection and reporting system that

0:03:38.920000 --> 0:03:42.160000
 can be integrated into
 your application.

0:03:42.160000 --> 0:03:43.340000
 And that's really what
 we're looking for.

0:03:43.340000 --> 0:03:45.280000
 So, hey, we want to
 collect this data.

0:03:45.280000 --> 0:03:47.360000
 We want to make it very easy
 to work with this data.

0:03:47.360000 --> 0:03:51.680000
 I will tell you that anything that I
 publish that's really frankly doesn't

0:03:51.680000 --> 0:03:53.040000
 even have to be production.

0:03:53.040000 --> 0:03:55.640000
 But if it's going to stick around for
 a while, I will implement application

0:03:55.640000 --> 0:03:59.080000
 insights because I want to see, I want
 to get this detailed information

0:03:59.080000 --> 0:04:02.200000
 about what's going on
 with my application.

0:04:02.200000 --> 0:04:06.080000
 It's extremely easy to implement as I
 will take a look at in just a minute.

0:04:06.080000 --> 0:04:09.100000
 And it's got just a rich
 set of information.

0:04:09.100000 --> 0:04:13.380000
 So, let's talk about what application
 insights actually gives you.

0:04:13.380000 --> 0:04:18.700000
 And you can see that there's this list
 of functionality and what are these.

0:04:18.700000 --> 0:04:20.900000
 One of my favorites is
 an application map.

0:04:20.900000 --> 0:04:24.340000
 And what that does is it shows
 you application dependencies.

0:04:24.340000 --> 0:04:29.580000
 So, I've got my client over here, for
 example, that's making calls to

0:04:29.580000 --> 0:04:34.360000
 my web app. And my web app is making
 calls out to various services.

0:04:34.360000 --> 0:04:40.920000
 And I can even see what the average
 call time is and how many calls have

0:04:40.920000 --> 0:04:45.860000
 been made. So, here
 I've got that one.

0:04:45.860000 --> 0:04:48.000000
 Those are running
 long, 13 seconds.

0:04:48.000000 --> 0:04:48.900000
 That's terrible.

0:04:48.900000 --> 0:04:54.240000
 With a 10% error rate or 502 calls, I
 can see my web app and what's going

0:04:54.240000 --> 0:04:58.920000
 on with that. And so, just right off
 the bat, good high-level view of

0:04:58.920000 --> 0:05:00.720000
 what's going on.

0:05:00.720000 --> 0:05:05.980000
 Smart detection is going to give
 me detection and alerting.

0:05:05.980000 --> 0:05:12.160000
 So, it's actually kind of AI-driven
 detection capabilities.

0:05:12.160000 --> 0:05:14.700000
 Livestream metrics, that's
 our live metric streams.

0:05:14.700000 --> 0:05:16.960000
 Excuse me, I'm going to give you
 exactly what it sounds like.

0:05:16.960000 --> 0:05:21.940000
 I want to see exactly what's going
 on with my system right now.

0:05:21.940000 --> 0:05:23.880000
 And I can do that.

0:05:23.880000 --> 0:05:26.500000
 I can search telemetry.

0:05:26.500000 --> 0:05:32.820000
 So, if I wanted to see, let's say, a
 particular response code, maybe 404,

0:05:32.820000 --> 0:05:39.580000
 405, 500, or even response code, 200s,
 I can search those and get results

0:05:39.580000 --> 0:05:45.220000
 back. I've got availability,
 which is very cool.

0:05:45.220000 --> 0:05:48.440000
 Availability is going to let
 me run periodic ping testing.

0:05:48.440000 --> 0:05:52.020000
 It's just going to make sure that
 the application is up and running.

0:05:52.020000 --> 0:05:55.640000
 And I can have things like
 multiple target locations.

0:05:55.640000 --> 0:06:00.020000
 So, if I have this deployed to different
 regions, I can test those.

0:06:00.020000 --> 0:06:03.960000
 I can set my success criteria, how often
 I want to test, what I'm testing

0:06:03.960000 --> 0:06:09.720000
 against. And I'm sorry, by the way,
 sorry, test locations is not where

0:06:09.720000 --> 0:06:12.060000
 my app is. That's from
 different locations.

0:06:12.060000 --> 0:06:15.920000
 So, if I want to make sure that my
 app is available, whether someone's

0:06:15.920000 --> 0:06:16.880000
 coming from the U.S.

0:06:16.880000 --> 0:06:22.020000
 or someone's coming from France or
 Brazil or Australia or wherever, I

0:06:22.020000 --> 0:06:23.360000
 can set that up.

0:06:23.360000 --> 0:06:26.920000
 And it sits there in the background
 and it runs these tests.

0:06:26.920000 --> 0:06:29.760000
 And I say ping test, it's going, it's
 making a call and making sure it

0:06:29.760000 --> 0:06:30.200000
 gets a response.

0:06:30.200000 --> 0:06:38.360000
 In this case, by default, a 200 response
 with a test timeout of two minutes.

0:06:38.360000 --> 0:06:42.340000
 I've got failure analysis,
 detailed failure analysis.

0:06:42.340000 --> 0:06:44.780000
 I can go and pull up my errors.

0:06:44.780000 --> 0:06:46.480000
 I can see overall errors.

0:06:46.480000 --> 0:06:50.700000
 I can see where my
 errors occurred.

0:06:50.700000 --> 0:06:56.200000
 So, I've got 204 errors, 203 of which
 happen in this 1GetWorkResponse

0:06:56.200000 --> 0:07:03.380000
 payload. And that's pretty much, again,
 you can kind of see what we have

0:07:03.380000 --> 0:07:07.980000
 there. I can do, over time,
 performance analysis, right?

0:07:07.980000 --> 0:07:13.780000
 So, I've got both live metrics streaming
 and I can do longer term performance

0:07:13.780000 --> 0:07:20.260000
 analysis. And so, a lot of capability
 that's coming in off of this data

0:07:20.260000 --> 0:07:23.720000
 that's being pulled
 in via telemetry.

0:07:23.720000 --> 0:07:25.740000
 Speaking of telemetry.

0:07:25.740000 --> 0:07:29.940000
 What is the telemetry that's captured
 through App Insights?

0:07:29.940000 --> 0:07:32.720000
 First of all, request rates, response
 times, and failure rates.

0:07:32.720000 --> 0:07:37.680000
 You actually saw all of those in the little
 screenshots that I ran through.

0:07:37.680000 --> 0:07:43.180000
 Dependency rates, response times, and failure
 rates for dependent applications.

0:07:43.180000 --> 0:07:46.760000
 The difference between these two
 are dependent services, right?

0:07:46.760000 --> 0:07:49.100000
 The first one is going to be
 coming into your application.

0:07:49.100000 --> 0:07:52.760000
 The second one is going to be your
 application connecting to back end

0:07:52.760000 --> 0:07:55.800000
 services, such as a
 database or storage.

0:07:55.800000 --> 0:07:57.840000
 You've got exceptions.

0:07:57.840000 --> 0:07:59.640000
 Pretty straightforward.

0:07:59.640000 --> 0:08:02.500000
 Page views and load performance.

0:08:02.500000 --> 0:08:10.020000
 You've got Ajax calls from web pages,
 performance counters from the, if

0:08:10.020000 --> 0:08:12.580000
 you're running Windows or
 Linux servers machines.

0:08:12.580000 --> 0:08:16.400000
 You can even get host diagnostics if
 you're running Docker, diagnostic

0:08:16.400000 --> 0:08:19.620000
 trace logs from your app, so you
 can have your custom trace logs.

0:08:19.620000 --> 0:08:25.040000
 If that's not enough, you can define
 your own events and metrics.

0:08:25.040000 --> 0:08:30.120000
 All of these can be collected and
 integrated into App Insights.

0:08:30.120000 --> 0:08:34.120000
 I'm going to talk about the integration
 in just a moment.

0:08:34.120000 --> 0:08:43.760000
 There are a number of reports that you
 can run with application insights.

0:08:43.760000 --> 0:08:46.820000
 Things like active users
 usage by hour of day.

0:08:46.820000 --> 0:08:48.560000
 You can see all of these.

0:08:48.560000 --> 0:08:50.800000
 What are some things even?

0:08:50.800000 --> 0:08:56.180000
 What can you likely do, this one's pretty
 cool, to improve user retention?

0:08:56.180000 --> 0:09:00.280000
 It actually has some
 reports there.

0:09:00.280000 --> 0:09:04.480000
 Speaking of retention, you've got things
 like in-period retention, cohort

0:09:04.480000 --> 0:09:09.680000
 analysis, and these are things that go
 into really kind of deep marketing

0:09:09.680000 --> 0:09:14.720000
 analysis of your website.

0:09:14.720000 --> 0:09:19.420000
 A ton of built-in reports to help you analyze
 the data that you're collecting

0:09:19.420000 --> 0:09:20.720000
 for an application.

0:09:20.720000 --> 0:09:26.460000
 Here we've got marketing and sales improvement
 built really directly into

0:09:26.460000 --> 0:09:28.720000
 application insights.

0:09:28.720000 --> 0:09:31.080000
 How do we get all of this?

0:09:31.080000 --> 0:09:35.900000
 You have a couple of different ways,
 really two different ways to pull

0:09:35.900000 --> 0:09:36.800000
 the integration.

0:09:36.800000 --> 0:09:40.220000
 Because at the end of the day, I have
 to pull this data in from my web

0:09:40.220000 --> 0:09:47.140000
 application. I can integrate this ideally
 into the application, but it

0:09:47.140000 --> 0:09:51.240000
 can also, in some circumstances,
 be integrated at runtime.

0:09:51.240000 --> 0:09:58.020000
 If I'm running ASP.NET or ASP.NET Core
 on Azure Windows Web Apps, then

0:09:58.020000 --> 0:10:00.800000
 those can be instrumented
 at runtime.

0:10:00.800000 --> 0:10:05.940000
 If I'm running ASP.NET on IIS, I can
 actually configure IIS to instrument

0:10:05.940000 --> 0:10:10.460000
 at runtime. What that means is that I don't
 need to build all of the instrumentation

0:10:10.460000 --> 0:10:11.600000
 into the application.

0:10:11.600000 --> 0:10:19.040000
 I can take ASP.NET Core application
 that has never seen, has nothing to

0:10:19.040000 --> 0:10:25.240000
 do with application insights, pull that
 up into an Azure Web App and configure

0:10:25.240000 --> 0:10:27.000000
 application insights
 at that level.

0:10:27.000000 --> 0:10:34.760000
 Ideally, what I can do is I can integrate
 my application insights into

0:10:34.760000 --> 0:10:36.180000
 the application itself.

0:10:36.180000 --> 0:10:39.560000
 Again, all of this telemetry
 is coming from somewhere.

0:10:39.560000 --> 0:10:44.040000
 The easiest thing to do to make sure
 you get the most telemetry is to

0:10:44.040000 --> 0:10:48.500000
 integrate that telemetry directly
 into your application.

0:10:48.500000 --> 0:10:54.220000
 That can work with any application on any
 framework as long as that framework

0:10:54.220000 --> 0:10:58.620000
 can make REST API calls,
 HTTPS calls.

0:10:58.620000 --> 0:11:01.740000
 Because at the end of the day, that's
 what application insights telemetry

0:11:01.740000 --> 0:11:06.620000
 collection is. It's just a REST API
 endpoint that's sitting there.

0:11:06.620000 --> 0:11:09.760000
 It's secured. You have to have a key
 to send data to it, but it's just

0:11:09.760000 --> 0:11:11.220000
 waiting for data.

0:11:11.220000 --> 0:11:17.260000
 Then you are really setting up your
 application to send it that data.

0:11:17.260000 --> 0:11:22.040000
 I could write custom REST API calls
 to do that, but there are a number

0:11:22.040000 --> 0:11:25.780000
 of libraries that are already built
 to make it easier to integrate.

0:11:25.780000 --> 0:11:32.740000
 For example, not surprisingly, on the
 Microsoft side, ASP.NET, ASP.NET

0:11:32.740000 --> 0:11:37.640000
 Core, and really any.NET and.NET
 Core Console applications.

0:11:37.640000 --> 0:11:41.360000
 All of these, I can pull
 in application insights.

0:11:41.360000 --> 0:11:49.120000
 But Java. I can also pull Java has
 a library, set of libraries for app

0:11:49.120000 --> 0:11:52.140000
 insights. Node.js,
 not surprisingly.

0:11:52.140000 --> 0:11:54.480000
 You've got a set of libraries
 for Node.js.

0:11:54.480000 --> 0:11:59.520000
 As I said, really do the
 line in the wrong place.

0:11:59.520000 --> 0:12:01.820000
 The catch all for anything
 is the REST API.

0:12:01.820000 --> 0:12:04.920000
 Even if you're using development environment
 that doesn't include that,

0:12:04.920000 --> 0:12:06.260000
 you've got the REST API.

0:12:06.260000 --> 0:12:11.000000
 There are also snippets that
 you can add to web pages.

0:12:11.000000 --> 0:12:15.380000
 It is highly likely, even if you've
 never seen application insights, if

0:12:15.380000 --> 0:12:20.000000
 you've got a public website, that you're
 using this kind of functionality.

0:12:20.000000 --> 0:12:24.740000
 Whether it's Google Analytics or Facebook
 Analytics or variations of those,

0:12:24.740000 --> 0:12:30.120000
 they all work with just really snippets
 of HTML that have been added into

0:12:30.120000 --> 0:12:34.520000
 your web pages that make calls back
 to the API to send it to LEMETRI.

0:12:34.520000 --> 0:12:36.120000
 This is no different.

0:12:36.120000 --> 0:12:40.740000
 The advantage of using ASP.NET or ASP
.NET Core is that that's already

0:12:40.740000 --> 0:12:43.240000
 built in. I can integrate that.

0:12:43.240000 --> 0:12:46.960000
 I can actually, for example, if I'm
 using Visual Studio, I can integrate

0:12:46.960000 --> 0:12:51.960000
 app insights into my application without
 writing any code whatsoever.

0:12:51.960000 --> 0:12:56.200000
 I literally right click, I add it in,
 and I've got application insights.

0:12:56.200000 --> 0:13:02.480000
 Now, what I want to do is I want to take
 you on a quick tour of application

0:13:02.480000 --> 0:13:06.520000
 insights. I'm going to show you how
 you would set it up, but I will also

0:13:06.520000 --> 0:13:09.280000
 tell you I've already got this up and
 running because I wanted to have

0:13:09.280000 --> 0:13:11.380000
 a little bit of data to show you.

0:13:11.380000 --> 0:13:17.960000
 I have a web app, and that web app
 is running an ASP.NET, I think it's

0:13:17.960000 --> 0:13:22.500000
 ASP.NET Core application, and I've
 got application insights integrated

0:13:22.500000 --> 0:13:27.160000
 into the application and
 at the web app itself.

0:13:27.160000 --> 0:13:30.140000
 So both at the code level and the web
 app, both of which were really just

0:13:30.140000 --> 0:13:34.100000
 clicks. Let's take a look
 at what we've got.

0:13:34.100000 --> 0:13:49.220000
 All right, I am in
 my Azure dashboard.

0:13:49.220000 --> 0:13:53.720000
 And I've got a web app that I've already
 deployed, and I've set that web

0:13:53.720000 --> 0:13:57.180000
 app up with application insights.

0:13:57.180000 --> 0:14:01.520000
 Now, to set up an existing web app,
 or when you deploy a web app with

0:14:01.520000 --> 0:14:05.520000
 application insights, all you have to
 do is go to the application insights

0:14:05.520000 --> 0:14:11.380000
 setting or item on the list,
 and you simply enable it.

0:14:11.380000 --> 0:14:16.000000
 Now, when you enable it, it's going to
 connect you to an application insights

0:14:16.000000 --> 0:14:21.000000
 resource, and it may actually
 create that resource.

0:14:21.000000 --> 0:14:23.980000
 And you set up the instrumentation,
 which I should have set it.NET Core,

0:14:23.980000 --> 0:14:26.380000
 but that's fine.

0:14:26.380000 --> 0:14:32.540000
 And you can profile, you can
 set up snapshot debugging.

0:14:32.540000 --> 0:14:37.720000
 I can also have dependency tracking
 to show compiled SQL commands and

0:14:37.720000 --> 0:14:41.040000
 local variables in a web request, which
 is pretty cool, but I don't have

0:14:41.040000 --> 0:14:45.280000
 any of those on this
 particular app.

0:14:45.280000 --> 0:14:51.740000
 Now, when I set that up, what it does
 is add a number of configuration

0:14:51.740000 --> 0:14:56.920000
 settings. So you can see I've got app
 insights, instrumentation key, profile

0:14:56.920000 --> 0:15:02.060000
 feature version, and diagnostic
 services, extension version.

0:15:02.060000 --> 0:15:06.940000
 All of those, I want to, yeah,
 there's four of them here.

0:15:06.940000 --> 0:15:11.480000
 I just skipped one extension version, feature
 version, key, and then diagnostic

0:15:11.480000 --> 0:15:14.620000
 services, extension
 service, version.

0:15:14.620000 --> 0:15:18.320000
 All of those were added in by simply
 going and selecting here.

0:15:18.320000 --> 0:15:27.420000
 Now, when I go here, I can view
 data on my application.

0:15:27.420000 --> 0:15:29.620000
 So this is all data
 on the application.

0:15:29.620000 --> 0:15:33.280000
 You can see I've got
 191 failed requests.

0:15:33.280000 --> 0:15:34.680000
 Oh, that's terrible.

0:15:34.680000 --> 0:15:37.000000
 I can see the average
 response time.

0:15:37.000000 --> 0:15:41.460000
 I can see my server request, which
 you can see spiked up here a little

0:15:41.460000 --> 0:15:46.520000
 while ago. Now, I can also go 30 minutes
 and get a little more granular

0:15:46.520000 --> 0:15:48.420000
 insight into this.

0:15:48.420000 --> 0:15:53.580000
 Now, I can drill down into this, but
 before I do, I'm just going to show

0:15:53.580000 --> 0:15:56.680000
 you the application.

0:15:56.680000 --> 0:15:57.920000
 This is my application.

0:15:57.920000 --> 0:16:01.820000
 This is one I use to test
 a bunch of things.

0:16:01.820000 --> 0:16:06.200000
 The ping check, just make sure
 that it actually can connect.

0:16:06.200000 --> 0:16:08.740000
 I've got a network load that's just
 going to send a bunch of requests.

0:16:08.740000 --> 0:16:11.600000
 In this case, I'm going to
 send a thousand requests.

0:16:11.600000 --> 0:16:14.300000
 I'll just send a hundred because
 that'll go quicker.

0:16:14.300000 --> 0:16:16.160000
 And execute that.

0:16:16.160000 --> 0:16:20.540000
 And then it's set up to randomly have
 some errors from 404 and 500 errors.

0:16:20.540000 --> 0:16:23.280000
 Get returned by the app.

0:16:23.280000 --> 0:16:29.260000
 I've got the ability to send requests
 to a queue, read those requests,

0:16:29.260000 --> 0:16:35.780000
 and also I've got a list of videos
 in a database that I can pull back.

0:16:35.780000 --> 0:16:40.980000
 All right. So that's the website and
 just generating some activity.

0:16:40.980000 --> 0:16:43.240000
 And that's what generated
 this activity.

0:16:43.240000 --> 0:16:46.380000
 Now, I can drill down, for example,
 if I go to failed requests.

0:16:46.380000 --> 0:16:48.380000
 What are those failed requests?

0:16:48.380000 --> 0:16:55.200000
 And if I come down here, I can see
 that I had overall two users.

0:16:55.200000 --> 0:17:01.460000
 I had 30 failed requests
 out of 154 total.

0:17:01.460000 --> 0:17:05.920000
 And if I go down here and I click on
 that, I can actually see these broken

0:17:05.920000 --> 0:17:07.780000
 out top three response codes.

0:17:07.780000 --> 0:17:12.100000
 There's only two, the
 404 and the 500.

0:17:12.100000 --> 0:17:20.140000
 And if I go into, let's say, the 404s,
 I can actually get the request

0:17:20.140000 --> 0:17:23.080000
 and response. And
 so I can go here.

0:17:23.080000 --> 0:17:25.080000
 So, okay, what in the
 world was this?

0:17:25.080000 --> 0:17:32.700000
 And I pull up that request and where
 that request fell in the overall

0:17:32.700000 --> 0:17:34.580000
 processing of the website.

0:17:34.580000 --> 0:17:38.120000
 And now I am not, again, this is where
 I'm not going to geek out too hard.

0:17:38.120000 --> 0:17:43.680000
 I can go in, I can get details
 on these, and lots of details.

0:17:43.680000 --> 0:17:46.240000
 I can see the request URL.

0:17:46.240000 --> 0:17:50.920000
 There's the full request
 URL that came in.

0:17:50.920000 --> 0:17:55.600000
 So lots of tracing
 in terms of data.

0:17:55.600000 --> 0:17:58.100000
 So 404 was probably
 not a great example.

0:17:58.100000 --> 0:18:03.180000
 I go to 500. And this is what
 I really want to show you.

0:18:03.180000 --> 0:18:04.940000
 I actually get the call stack.

0:18:04.940000 --> 0:18:09.680000
 This is the call stack of the error
 that's returned by the application,

0:18:09.680000 --> 0:18:14.640000
 404. Didn't get that 404 because,
 well, that's not going to come in.

0:18:14.640000 --> 0:18:18.720000
 And so that's a system argument
 and all exception.

0:18:18.720000 --> 0:18:20.800000
 Okay, so, all right.

0:18:20.800000 --> 0:18:22.480000
 Those are failures again.

0:18:22.480000 --> 0:18:24.420000
 You can geek out a
 bit more on that.

0:18:24.420000 --> 0:18:25.860000
 But I'm going to try now too.

0:18:25.860000 --> 0:18:28.580000
 Application map, love this.

0:18:28.580000 --> 0:18:31.420000
 I'm going to view my application
 dependencies.

0:18:31.420000 --> 0:18:35.400000
 I can see that I've got
 a client out here.

0:18:35.400000 --> 0:18:37.560000
 I can view details of the client.

0:18:37.560000 --> 0:18:43.300000
 Things like the slowest page, which was
 the root, not surprisingly because

0:18:43.300000 --> 0:18:45.380000
 that's all the pages.

0:18:45.380000 --> 0:18:49.500000
 All my failed dependencies,
 54 have common properties.

0:18:49.500000 --> 0:18:50.620000
 I can see the target.

0:18:50.620000 --> 0:18:53.100000
 I can go to the details
 from that client.

0:18:53.100000 --> 0:18:56.220000
 So I might have different error
 rates from different clients.

0:18:56.220000 --> 0:19:00.740000
 All right. And I can actually click
 on the connection information.

0:19:00.740000 --> 0:19:03.980000
 I can also go to my
 application itself.

0:19:03.980000 --> 0:19:09.180000
 Get information on the application,
 fail and request, slowest requests.

0:19:09.180000 --> 0:19:13.060000
 Get videos is the slowest
 average at 2.1 seconds.

0:19:13.060000 --> 0:19:16.520000
 And then I can even go and
 look at some back end.

0:19:16.520000 --> 0:19:17.940000
 So I've got a database set up.

0:19:17.940000 --> 0:19:20.000000
 I've got an Azure Q set up.

0:19:20.000000 --> 0:19:25.880000
 I can see things like communications,
 investigate performance, which I

0:19:25.880000 --> 0:19:27.520000
 think is typically going
 to take a little.

0:19:27.520000 --> 0:19:29.160000
 That's not too bad.

0:19:29.160000 --> 0:19:35.660000
 And that's showing me
 a dependency count.

0:19:35.660000 --> 0:19:38.660000
 It's CPU. Show that, et cetera.

0:19:38.660000 --> 0:19:46.140000
 So you can see quite a number
 of different details.

0:19:46.140000 --> 0:19:49.540000
 And again, I'm not going into massive
 details on this because I could

0:19:49.540000 --> 0:19:51.660000
 make this take two hours.

0:19:51.660000 --> 0:19:54.220000
 I can analyze this.

0:19:54.220000 --> 0:19:55.920000
 I can profile deeper.

0:19:55.920000 --> 0:19:58.380000
 Lots of configuration
 options there.

0:19:58.380000 --> 0:19:59.840000
 Went back too far.

0:19:59.840000 --> 0:20:04.340000
 Let's go there. And then just the other
 thing I wanted to show you here,

0:20:04.340000 --> 0:20:07.220000
 just because it's kind of
 fun, live metrics stream.

0:20:07.220000 --> 0:20:14.880000
 Start that up. All right, here's
 my live metrics stream.

0:20:14.880000 --> 0:20:17.260000
 Wait until that gets cranking
 just a little bit.

0:20:17.260000 --> 0:20:20.120000
 There we go. That's some
 things going on.

0:20:20.120000 --> 0:20:22.680000
 Pop that over to one side.

0:20:22.680000 --> 0:20:29.140000
 And see if we get a little
 bit of a load here.

0:20:29.140000 --> 0:20:31.200000
 Whatever reason, it
 decided not to go.

0:20:31.200000 --> 0:20:33.820000
 There you go. And you can see
 these exceptions coming in.

0:20:33.820000 --> 0:20:35.860000
 You see my request failure rate.

0:20:35.860000 --> 0:20:39.980000
 Now that was actually pretty
 small because I only did 100.

0:20:39.980000 --> 0:20:47.400000
 Let's go ahead and do 1000.

0:20:47.400000 --> 0:20:48.980000
 And that should crank things up.

0:20:48.980000 --> 0:20:51.280000
 You can see the request
 rate coming in.

0:20:51.280000 --> 0:20:54.580000
 Dependency calls here.

0:20:54.580000 --> 0:20:56.940000
 Let's see, dependency
 call durations.

0:20:56.940000 --> 0:20:59.960000
 There's no dependency
 call failures.

0:20:59.960000 --> 0:21:03.020000
 But you see that request failure rate
 that's kind of going up and down

0:21:03.020000 --> 0:21:06.460000
 a little bit. And the overall
 request duration.

0:21:06.460000 --> 0:21:09.720000
 Just lots of frankly cool
 information that I've got.

0:21:09.720000 --> 0:21:13.580000
 It's running. And I promise you, I know
 you didn't see it, but I didn't

0:21:13.580000 --> 0:21:18.620000
 put any code. I didn't have to write
 any code to get this information.

0:21:18.620000 --> 0:21:21.200000
 This information is just given
 to me by configuration.

0:21:21.200000 --> 0:21:23.160000
 Now you can write code.

0:21:23.160000 --> 0:21:27.400000
 You can have your own custom telemetry,
 your own custom errors that get

0:21:27.400000 --> 0:21:31.460000
 delivered into the application
 insights application insights.

0:21:31.460000 --> 0:21:35.700000
 Also, if you're a Windows developer,
 a Microsoft developer and you use

0:21:35.700000 --> 0:21:40.360000
 Visual Studio, application insights
 integrates very well so you can use

0:21:40.360000 --> 0:21:43.920000
 it actually while you're in the development
 phase, not just in production.

0:21:43.920000 --> 0:21:49.360000
 So application insights, a powerful
 telemetry tool that you can use to

0:21:49.360000 --> 0:21:55.400000
 really hook up and monitor
 your applications.