Well, we are back with our provenance application and what we're going to talk about now is metrics and monitoring. So, there's a few things to call out with metrics and monitoring. So I have a new package here and it's called metrics support. There's two classes in here, one is a health check and the other is a metrics controller. And so let's talk about the health check first. So this is fairly straightforward and really all I'm doing here is exposing a get request, right, to health check and rendering a response. In this case I'm rendering a JSON response or sorry, a text response saying that hey, I'm healthy. And so this is important, right, that there's an end point on your application that simply just tells someone of it who's interested whether your application is healthy or not. And if you think of when you're deploying your application to a platform, you might have been using something like Kubernetes. All of those platforms tend to require a health check. And it's how the platform knows that your application is healthy and such that it could respond and potentially email or text you and say, hey, your application is down. So, that's the first bit is the health check, where that gets wired in. So this is our application up top and we're starting our application and one of the endpoints that we talk about here is our health check. So this is registering controllers or registering endpoints with our application. Okay, so that's the health check. We even have a little test for the health check, right, that we could look here and again it's saying I'm healthy. So, we'll also be per the last video looking to see whether or not you're testing your endpoints for metrics and monitoring. Okay, so that's monitoring, let's switch over to metrics and in the test above. Right, we have a test for metrics. And what we're getting back is data on the number of requests that we might be making to one of our endpoints. So, if I bounce back into articles for a minute and I look at our articles controller, you'll notice something, right, that in here I'm actually giving the articles controller some information about requests. Right, so I pass in this metrics registry. Right, and then I actually register a articles request and then an articles available request. And these are just meters, right. So these are just looking at the number of requests, right, to either of these endpoints and then displaying that meter to the user. So you could see it during one of these, right. We basically say we put a mark in here, right. And this is signaling to the metrics registry that somebody went through this method and we responded accordingly. Okay, so where metrics get wired in is a similar place in the application, right. It's just the line below. So metrics controller. And this is where we're baking and also Prometheus. So Prometheus is a place that or application that collects data and then Grafana is typically used to display that data in a graphical user interface. Prometheus you can think of as a database, much like Postgres, although it's specialized for collecting metrics data. So when we start up our application, here's our main method for our Java class, right. This is going in and starting our application. This little basic app that we created here, it has a couple of things, right. The app that we have extends basic app. And in order to register, right, those handlers, we need to do just that. And these are the lines of code that I was talking about to register both our health check and our metrics controller. And then naturally just above is where we register our articles controller. Okay, so this is what some code looks like. As you're thinking about baking in metrics and monitoring to your application. And naturally we're going to send that data to something like Prometheus and then also visualize that data with something like Grafana. Okay, thank you.