Robley Gori

In this article, we'll use Redis and Celery with Flask to create an asynchronous messaging system in order to create a simple reminder application.

Asynchronous Tasks Using Flask, Redis and Celery

Asynchronous Tasks Using Flask, Redis, and Celery

Usman Malik

Time-series data changes with time. In this article, we'll be using PyTorch to analyze time-series data and predict future values using deep learning.

Time Series Prediction using LSTM with PyTorch in Python

<h2 id="introduction">Introduction</h2>
Sorting is a crucial aspect of digesting data. For us humans, it's much more natural to sort things that have something in common like the date of publishing, alphabetical order, articles belonging to an author, from smallest to largest, etc...
This makes it a lot easier to comprehend the data as it's logically connected rather than dispersed all around.
Human sorting is intuitive and simple, and thus often inefficient. We're usually not working with more than two elements we wish to sort. Computers are able to store huge amounts of data and element locations in their memory, which allow them to sort collections in a way humans couldn't, not to mention the speed of accessing/moving elements.
<h2 id="bubblesort">Bubble Sort</h2>
Bubble Sort is, in most cases, the first sorting algorithm any computer science enthusiast will encounter. It's the simplest and most intuitive sorting algorithms, which is one of the main reasons why it's taught to novice programmers/students.
It works by swapping adjacent elements, according to an order criteria. For example, if we want to sort a collection's elements from the smallest to largest - if the first element is larger than the second, they're swapped. This simple exchange is repeated with adjacent indexes until the collection is eventually sorted.
The exit condition for the algorithm is when we iterate through the whole collection without swapping a single element - which means it's fully sorted.
Here's a visual representation of how bubble sort works:
<img src="https://stackabuse.s3.amazonaws.com/media/bubble-sort-in-java-1.gif" alt="bubble sort visualization animation gif">
As you can see, the name itself comes from the visual illusion of elements &quot;bubbling up&quot; to their desired place. If you follow a certain element, say, <code>8</code> - you can notice it &quot;bubbling up&quot; to it's correct place in this example.
<h2 id="implementation">Implementation</h2>
With a brief overview of the theory behind Bubble Sort out of the way, let's implement it by sorting two different types of collections. First, we'll sort a simple array, and afterwards we'll sort an <code>ArrayList</code> with a custom object and a <code>compareTo()</code> method.
<h3 id="sortingarrays">Sorting Arrays</h3>
Let's start out by sorting a simple array of integers:
<pre><code class="hljs">public void bubbleSort(int[] array) {
 boolean sorted = false;
 int temp;
 while (!sorted) {
 sorted = true;
 for (int i = 0; i &lt; array.length - 1; i++) {
 if (a[i] &gt; a[i+1]) {
 temp = a[i];
 a[i] = a[i+1];
 a[i+1] = temp;
 sorted = false;
 }
 }
 }
}
</code></pre>
The <code>sorted</code> flag is used to signal if the array is sorted or not. If there's no reason to swap any element, or rather <code>a[i]</code> is always less than <code>a[i+1]</code> in a given iteration, the <code>sorted</code> flag is never reset to <code>false</code>.
Since it stays <code>true</code>, the array is sorted and we break out of the loop.
Running this piece of code:
<pre><code class="hljs">int[] array = new int[]{5, 6, 7, 2, 4, 1, 7};
bubbleSort(array);
System.out.println(Arrays.toString(array));
</code></pre>
Will yield:
<pre><code class="hljs">[1, 2, 4, 5, 6, 7, 7]
</code></pre>
Note: Since arrays are treated as objects in Java, having a <code>void</code> return type is absolutely valid when sorting arrays, and the contents are not copied at face-value when using it as an argument. In this case the array is sorted &quot;in place&quot;.
<h3 id="sortingarraylists">Sorting ArrayLists</h3>
A more common scenario would be sorting an <code>ArrayList</code> populated by non-numerical objects. These can be employees, results from a database, users, etc. Since we don't know ahead of time how to sort these objects, it will need to be provided by the caller via the <code>comapreTo()</code> method.
Let's define a class for our objects that'll be stored in a collection:
<pre><code class="hljs">public class Element {
 private int id;

 public Element(int id) {
 this.id = id;
 }

 // Getters and setters

 public int compareTo(Element element) {
 int res = 0;
 if (this.id &lt; element.getId()) {
 res =- 1;
 }
 if (this.id &gt; element.getId()) {
 res = 1;
 }
 return res;
 }
}
</code></pre>
It's a very simple class with a single field - <code>id</code>. We can also <code>@Override</code> the <code>toString()</code> method if we'd like to print the results, but for the sake of brevity, let's not do that here and simply use the <code>getId()</code> method instead.
When it comes to sorting <code>ArrayList</code>s, since we're working with objects it's a little different than sorting simple arrays of primitive values since we can't just use relational operators.
Now, our <code>compareTo()</code> method simply compares the <code>id</code>s and returns <code>-1</code> if the <code>id</code> of the current element is lesser than the element we're comparing it to, <code>1</code> if the <code>id</code> of the current element is higher, or <code>0</code> if they are equal.
Really, you can implement the comparing functionality in any way you'd like.
Now, let's implement Bubble Sort again:
<pre><code class="hljs">public void bubbleSortArrayList(List&lt;Element&gt; list) {
 Element temp;
 boolean sorted = false;

 while (!sorted) {
 sorted = true;
 for (int i = 0; i &lt; list.size()-1; i++) {
 if (list.get(i).compareTo(list.get(i + 1)) &gt; 0) {
 temp = list.get(i);
 list.set(i, list.get(i + 1));
 list.set(i + 1, temp);
 sorted = false;
 }
 }
 }
}
</code></pre>
This is pretty straightforward code, practically the same as the code in the example with arrays, utilizing the methods provided by the <code>List</code> interface.
Now, let's populate an <code>ArrayList</code> with a few elements:
<pre><code class="hljs">List&lt;Element&gt; list = new ArrayList&lt;&gt;();

// Create elements w/ IDs 0-24
for (int i = 0; i &lt; 25; i++) {
 list.add(new Element(i));
}

// Move the elements to a random order
Collections.shuffle(list);
</code></pre>
And we can sort it:
<pre><code class="hljs">// Print list before sorting
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));

// Sort the list
bubbleSort.bubbleSortArrayList(list);

System.out.println();

// Print sorted list
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));
</code></pre>
As expected, the output is:
<pre><code class="hljs">17, 13, 14, 5, 15, 22, 24, 7, 3, 9, 21, 10, 1, 11, 18, 20, 12, 8, 4, 19, 0, 23, 16, 2, 6,
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
</code></pre>
<h2 id="thecollectionsapi">The Collections API</h2>
A great thing about the Collections API that ships with Java 8 is helper methods that allow you to quickly and easily sort collections. We just need to implement the <code>Comparable</code> interface for the elements we wish to sort later on.
Let's change our <code>Element</code> class so that it implements the <code>Comparable</code> interface:
<pre><code class="hljs">public class Element implements Comparable&lt;Element&gt; {
 private int id;

 // Constructor, getters and setters

 @Override
 public int compareTo(Element element) {
 int res = 0;
 if (this.id &lt; element.getId()) {
 res =- 1;
 }
 if (this.id &gt; element.getId()) {
 res = 1;
 }
 return res;
 }
}
</code></pre>
As you can see, the <code>Element</code> class is pretty much the same as before. This time, we implemented the <code>Comparable</code> interface and overridden it's <code>compareTo()</code> method with the same logic as before.
Now, we can simply call <code>Collections.sort()</code> on our list:
<pre><code class="hljs">List&lt;Element&gt; list = new ArrayList&lt;&gt;();
for (int i = 0; i &lt; 10000; i++) {
 list.add(new Element(i));
}

Collections.shuffle(list);

// Print shuffled list
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));

// Sort the list
Collections.sort(list);

System.out.println();

// Print sorted list
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));
</code></pre>
The <code>sort()</code> method from the Collections API uses Quick Sort to sort the given collection. This results in huge performance benefits compared to Bubble Sort, but we'll save that for another article.
<h2 id="timecomplexity">Time Complexity</h2>
The time complexity (both average and worst) of Bubble Sort is O(n^2). This is, realistically observing, horrible for a sorting algorithm.
Albeit horrible, here's how the algorithm performed when sorting 10,000 objects in a collection:
<pre><code class="hljs">List&lt;Element&gt; list = new ArrayList&lt;&gt;();
for (int i = 0; i &lt; 10000; i++) {
 list.add(new Element(i));
}

Collections.shuffle(list);

// Print shuffled collection
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));

long startTime = System.nanoTime();
bubbleSort.bubbleSortArrayList(list);
long endTime = System.nanoTime();

// Print sorted collection
list.forEach(e -&gt; System.out.print(e.getId() + &quot;, &quot;));

System.out.println();

// Print runtime in nanoseconds
System.out.println(&quot;Bubble Sort runtime: &quot; + (endTime - startTime));
</code></pre>
And here are the results in seconds after running it 10 times:
<table class="table table-striped" style="white-space:nowrap; font-size:15px;">
 <tr>
 <th>Bubble Sort</th>
 <th>time(s)</th>
 <th></th>
 </tr>
 <tr>
 <td>First Run</td>
 <td>0.5885202</td>
 </tr>
 <tr>
 <td>Second Run</td>
 <td>0.6647364</td>
 </tr>
 <tr>
 <td>Third Run</td>
 <td>0.5748066</td>
 </tr>
 <tr>
 <td>Fourth Run</td>
 <td>0.5266222</td>
 </tr>
 <tr>
 <td>Fifth Run</td>
 <td>0.522961</td>
 </tr>
 <tr>
 <td>Sixth Run</td>
 <td>0.5033268</td>
 </tr>
 <tr>
 <td>Seventh Run</td>
 <td>0.5044489</td>
 </tr>
 <tr>
 <td>Eight Run</td>
 <td>0.6409187</td>
 </tr>
 <tr>
 <td>Ninth Run</td>
 <td>0.6021427</td>
 </tr>
 <tr>
 <td>Tenth Run</td>
 <td>0.694294</td>
 </tr>
</table>
With an average runtime of ~0.5s for 10,000 objects, will you really need algorithms that perform better? Most of the time, not really, unless you have an application with a high load that requires a fast response time.
If you're doing more complex comparisons than just comparing <code>id</code>s and have a huge collection, much larger than this one - yes, using an advanced algorithm with a much better time complexity will affect your performance significantly.
For reference, the <code>sort()</code> method from the Collections API sorted this same array of 10,000 elements in just 0.01s consistently. So even if there's no real need to sort your collections faster than 0.5s, using a built-in sorter provided by the Collections API will both save you time when coding and improve your application.
<h2 id="conclusion">Conclusion</h2>
Bubble Sort is, in most cases, the first sorting algorithm any computer science enthusiast will encounter. It's the simplest and most intuitive sorting algorithm which is one of the main reasons why it's being taught at an early point.
We saw that this simple sorting algorithm works by swapping adjacent elements, according to a given order criteria. For example, if we want to sort a collection's elements from the smallest to largest - if the first element is larger than the second, they're swapped. This simple exchange is repeated for adjacent indexes until the collection is eventually sorted.
It's horribly inefficient and given that there are much more efficient algorithms built-in to Java in the Collections API, we'd advise that you don't use this algorithm for any production applications.

David Landup

Bubble Sort is in most cases the first sorting algorithm you'll come across. In this article, we'll be taking a deep dive into the algorithm, how it works and then implement it in Java.

Bubble Sort in Java

<h2 id="introduction">Introduction</h2>
Users don't only consume data, they also produce data and upload it. They can send data through applications like messengers or email to specific recipients or upload files to social networks and data streaming platforms such as Facebook or YouTube.
That being said, almost every interactive website today supports file uploads.
<h2 id="fileuploadinglibraries">File Uploading Libraries</h2>
There are several Node libraries available on NPM that can simplify the process of validating and uploading files to the server. Among them, the most popular choice these days are <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/multer">Multer</a>, <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/formidable">Formidable</a>, and <a rel="nofollow noopener" target="_blank" href="https://www.npmjs.com/package/multiparty">Multiparty</a>.
They all have stable versions and are backed by an online community of open source developers.
<h2 id="whatismulter">What is Multer?</h2>
Multer is a popular Node.js middleware used for handling <code>multipart/form-data</code> requests. It makes use of <a rel="nofollow noopener" target="_blank" href="https://github.com/mscdex/busboy">busboy</a> to parse any data that it received through an HTML form. This greatly enhances its performance because the busboy module is unmatched when it comes to analyzing form data.
Multer provides us control and flexibility when handling <code>multipart/form-data</code> requests - we get detailed information about each uploaded file, the ability to add a custom storage engine, validation of files according to our needs, the ability to set limits on uploaded files, etc.
<h2 id="projectsetup">Project Setup</h2>
Since we won't be storing our images in a database, but rather a simple folder for brevity and simplicity, let's make another folder within our project folder and name it, say, <code>uploads</code>.
Now, let's install Express:
<pre><code class="hljs">$ npm i express
</code></pre>
And finally, let's install Multer:
<pre><code class="hljs">$ npm i multer
</code></pre>
<h2 id="projectimplementation">Project Implementation</h2>
At this point, we are ready to write some code, starting off with the HTML forms that we'll use to harvest information.
Let's start off with the form for uploading a single file:
<pre><code class="hljs">&lt;form method=&quot;POST&quot; action=&quot;/upload-profile-pic&quot; enctype=&quot;multipart/form-data&quot;&gt;
 &lt;div&gt;
 &lt;label&gt;Select your profile picture:&lt;/label&gt;
 &lt;input type=&quot;file&quot; name=&quot;profile_pic&quot; /&gt;
 &lt;/div&gt;
 &lt;div&gt;
 &lt;input type=&quot;submit&quot; name=&quot;btn_upload_profile_pic&quot; value=&quot;Upload&quot; /&gt;
 &lt;/div&gt;
&lt;/form&gt;
</code></pre>
And then with a form that allows us to upload multiple files:
<pre><code class="hljs">&lt;form method=&quot;POST&quot; action=&quot;/upload-multiple-images&quot; enctype=&quot;multipart/form-data&quot;&gt;
 &lt;div&gt;
 &lt;label&gt;Select multiple images:&lt;/label&gt;
 &lt;input type=&quot;file&quot; name=&quot;multiple_images&quot; multiple /&gt;
 &lt;/div&gt;
 &lt;div&gt;
 &lt;input type=&quot;submit&quot; name=&quot;btn_upload_multiple_images&quot; value=&quot;Upload&quot; /&gt;
 &lt;/div&gt;
&lt;/form&gt;
</code></pre>
You can either put these forms on separate pages or on the same one. For the purpose of this tutorial, they're one after another:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-file-uploads-in-node-with-express-and-multer-1.JPG" alt="HTML5 forms for submitting files to server">
The HTML forms are pretty straightforward, accepting <code>multipart/form-data</code> and routing to the adequate functions that handle their requests.
<h3 id="expressapplication">Express Application</h3>
With our forms ready, we can work on the actual logic for uploading and validating files through Express.
Let's create a file called <code>app.js</code> in the project root and start by importing the required modules:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const multer = require(&#x27;multer&#x27;);
const path = require(&#x27;path&#x27;);
</code></pre>
Now, let's create our Express app:
<pre><code class="hljs">const app = express();
</code></pre>
And finally, let's set up the port on which it'll run:
<pre><code class="hljs">const port = process.env.PORT || 3000;
</code></pre>
The <code>public</code> directory off of our root folder contains the static files we want to serve, so let's set it as a static directory using <code>express.static</code>:
<pre><code class="hljs">app.use(express.static(__dirname + &#x27;/public&#x27;));
</code></pre>
At this point, let's define the storage location for our images:
<pre><code class="hljs">const storage = multer.diskStorage({
 destination: function(req, file, cb) {
 cb(null, &#x27;uploads/&#x27;);
 },

 // By default, multer removes file extensions so let&#x27;s add them back
 filename: function(req, file, cb) {
 cb(null, file.fieldname + &#x27;-&#x27; + Date.now() + path.extname(file.originalname));
 }
});
</code></pre>
And finally, let's run the app using the port we set earlier:
<pre><code class="hljs">app.listen(port, () =&gt; console.log(`Listening on port ${port}...`));
</code></pre>
<h3 id="filevalidationandupload">File Validation and Upload</h3>
For fundamental security reasons, we'll want to validate files before uploading them to our servers. Let's edit the <code>app.js</code> file and add both functionalities:
<pre><code class="hljs">app.post(&#x27;/upload-profile-pic&#x27;, (req, res) =&gt; {
 // &#x27;profile_pic&#x27; is the name of our file input field in the HTML form
 let upload = multer({ storage: storage, fileFilter: helpers.imageFilter }).single(&#x27;profile_pic&#x27;);

 upload(req, res, function(err) {
 // req.file contains information of uploaded file
 // req.body contains information of text fields, if there were any

 if (req.fileValidationError) {
 return res.send(req.fileValidationError);
 }
 else if (!req.file) {
 return res.send(&#x27;Please select an image to upload&#x27;);
 }
 else if (err instanceof multer.MulterError) {
 return res.send(err);
 }
 else if (err) {
 return res.send(err);
 }

 // Display uploaded image for user validation
 res.send(`You have uploaded this image: &lt;hr/&gt;&lt;img src=&quot;${req.file.path}&quot; width=&quot;500&quot;&gt;&lt;hr /&gt;&lt;a href=&quot;./&quot;&gt;Upload another image&lt;/a&gt;`);
 });
});
</code></pre>
Here, we've accepted an HTTP POST request, in which the image information is embodied. The function that actually takes care of the upload functionality is the <code>multer().single()</code> method.
You might have noticed the <code>fileFilter: helpers.imageFilter</code> but we haven't yet created/imported the <code>helpers</code> file. So, let's create a new file in our project directory and name it <code>helpers.js</code>. Here we will write some code that is used to check whether the submitted file is an image or not.
<pre><code class="hljs">const imageFilter = function(req, file, cb) {
 // Accept images only
 if (!file.originalname.match(/\.(jpg|JPG|jpeg|JPEG|png|PNG|gif|GIF)$/)) {
 req.fileValidationError = &#x27;Only image files are allowed!&#x27;;
 return cb(new Error(&#x27;Only image files are allowed!&#x27;), false);
 }
 cb(null, true);
};
exports.imageFilter = imageFilter;
</code></pre>
Of course, to use this module, we'll have to import it at the top of our <code>app.js</code> file:
<pre><code class="hljs">const helpers = require(&#x27;./helpers&#x27;);
</code></pre>
Now, we can run our application and validate that it's working properly:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-file-uploads-in-node-with-express-and-multer-2.JPG" alt="Uploaded single image">
<h3 id="uploadingmultiplefiles">Uploading Multiple Files</h3>
Uploading multiple files is essentially the same as uploading a single file. Though, instead of the <code>multer().single()</code> function, we use the <code>multer().array()</code> function:
<pre><code class="hljs">app.post(&#x27;/upload-multiple-images&#x27;, (req, res) =&gt; {
 // 10 is the limit I&#x27;ve defined for number of uploaded files at once
 // &#x27;multiple_images&#x27; is the name of our file input field
 let upload = multer({ storage: storage, fileFilter: helpers.imageFilter }).array(&#x27;multiple_images&#x27;, 10);

 upload(req, res, function(err) {
 if (req.fileValidationError) {
 return res.send(req.fileValidationError);
 }
 else if (...) // The same as when uploading single images

 let result = &quot;You have uploaded these images: &lt;hr /&gt;&quot;;
 const files = req.files;
 let index, len;

 // Loop through all the uploaded images and display them on frontend
 for (index = 0, len = files.length; index &lt; len; ++index) {
 result += `&lt;img src=&quot;${files[index].path}&quot; width=&quot;300&quot; style=&quot;margin-right: 20px;&quot;&gt;`;
 }
 result += &#x27;&lt;hr/&gt;&lt;a href=&quot;./&quot;&gt;Upload more images&lt;/a&gt;&#x27;;
 res.send(result);
 });
});
</code></pre>
And now, to validate if everything is working correctly:
<img src="https://stackabuse.s3.amazonaws.com/media/handling-file-uploads-in-node-with-express-and-multer-3.JPG" alt="Uploaded multiple image">
<h2 id="conclusion">Conclusion</h2>
Users don't only consume data, they produce data and, in many cases, need to upload it to a web server. They can send data through applications like messengers or email to specific recipients, or they can upload files to social networks and data streaming platforms such as Facebook or YouTube.
In this article we've used Express.js and the Multer library to handle basic file uploading functionality in a simple web application.

Guest Contributor

Most interactive websites today support file uploads. In this article, we'll be using Multer, Formidable and Multiparty to facilitate file upload capabilities in Node.js.

Handling File Uploads in Node.js with Express and Multer

<h2 id="introduction">Introduction</h2>
Monitoring an application's health and metrics helps us manage it better, notice unoptimized behavior and get closer to its performance. This especially holds true when we're developing a system with many microservices, where monitoring each service can prove to be crucial when it comes to maintaining our system.
Based on this information, we can draw conclusions and decide which microservice needs to scale if further performance improvements can't be achieved with the current setup.
In this article, we'll cover how to monitor Spring Boot web applications. We will be using three projects to achieve this:
<ul>
<li><a rel="nofollow noopener" target="_blank" href="https://micrometer.io/">Micrometer</a>: Exposes the metrics from our application</li>
<li><a rel="nofollow noopener" target="_blank" href="https://prometheus.io/">Prometheus</a>: Stores our metric data</li>
<li><a rel="nofollow noopener" target="_blank" href="https://grafana.com">Grafana</a>: Visualizes our data in graphs</li>
</ul>
This might look like a lot, especially compared to just using the <a rel="nofollow noopener" target="_blank" href=" https://spring.io/guides/gs/actuator-service/">Spring Boot Actuator</a> project, but it's very easy to implement all of them with just a few configurations.
To make things even easier, we'll be using <a rel="nofollow noopener" target="_blank" href="https://www.docker.com/">Docker</a> to run Prometheus and Grafana since they both have official Docker images. If you're not familiar with Docker, you can check out our article <a target="_blank" href="/docker-a-high-level-introduction/">Docker: A High-Level Introduction</a>.
Please note that these metrics will give you aggregated information over an interval of time. If you want to check information about an individual request at a particular time and what happened to it, then this might not be the solution for you.
In that case, you probably need a distributed tracing system which we have covered in detail in <a target="_blank" href="/spring-cloud-distributed-tracing-with-sleuth">Distributed Tracing with Sleuth</a>.
<h2 id="springbootactuator">Spring Boot Actuator</h2>
We'll start off with a simple REST service using <a rel="nofollow noopener" target="_blank" href="https://start.spring.io/">Spring Initializr</a> that contains a single endpoint of <code>/hello</code> and running on the default port of <code>8080</code>.
Besides, this application also has the <code>spring-boot-starter-actuator</code> dependency, which provides <a rel="nofollow noopener" target="_blank" href="https://docs.spring.io/spring-boot/docs/current/reference/html/production-ready-endpoints.html">production-ready endpoints</a> that you can use for your application. These endpoints fall under a common prefix of <code>/actuator</code> and are, by default, protected.
Expose them individually, or all at once, by adding the following properties in <code>application.properties</code>:
<pre><code class="hljs">management.endpoints.web.exposure.include=*
</code></pre>
To check, let's navigate our browser to <code>http://localhost:8080/actuator</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-1.png" alt="spring boot monitor actuator">
You can see all the endpoints that Actuator exposes such as <code>/health</code>, <code>/metrics</code>, <code>/mappings</code>, etc. Let's open up the <code>/metrics</code> endpoint of the Actuator by navigating our browser to <code>http://localhost:8080/actuator/metrics</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-2.png" alt="spring boot monitor mappings and endpoints">
As you can see, there's a bunch of information about our application here, such as information about threads, Tomcat sessions, classes, the buffer, etc. Let's go deeper and retrieve information about the JVM memory used:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-3.png" alt="spring boot monitor actuator metrics memeory">
Now, using the Spring Boot Actuator like this does yield a lot of information about your application, but it's not very user-friendly. It can be integrated with <a rel="nofollow noopener" target="_blank" href="https://github.com/codecentric/spring-boot-admin">Spring Boot Admin</a> for visualization, but it has its limitations and is less popular.
Tools like Prometheus, <a rel="nofollow noopener" target="_blank" href="https://github.com/Netflix/atlas">Netflix Atlas</a>, and Grafana are more commonly used for the monitoring and visualization and are language/framework-independent.
Each of these tools has its own set of data formats and converting the <code>/metrics</code> data for each one would be a pain. To avoid converting them ourselves, we need a vendor-neutral data provider, such as Micrometer.
<h2 id="micrometer">Micrometer</h2>
To solve this problem of being a vendor-neutral data provider, Micrometer came to be. It exposes Actuator metrics to external monitoring systems such as Prometheus, Netflix Atlas, <a rel="nofollow noopener" target="_blank" href="https://aws.amazon.com/cloudwatch/">AWS CloudWatch</a>, and many more.
They quite correctly describe themselves as:
<blockquote>
Think SLF4J, but for metrics.
</blockquote>
Just as a refresher, SLF4J is a logging facade for other Java logging frameworks. SLF4J itself does not have any logging implementation. The idea is that you write code using SLF4J API and the real implementation of it comes from the framework you choose. It could be any of the popular frameworks like <a rel="nofollow noopener" target="_blank" href="https://logging.apache.org/log4j/2.x/">Log4j</a>, <a rel="nofollow noopener" target="_blank" href="http://logback.qos.ch/">Logback</a>, etc.
Similarly, Micrometer automatically exposes <code>/actuator/metrics</code> data into something your monitoring system can understand. All you need to do is include that vendor-specific micrometer dependency in your application.
Micrometer is a separate open-sourced project and is not in the Spring ecosystem, so we have to explicitly add it as a dependency. Since we will be using Prometheus, let's add it's specific dependency in our <code>pom.xml</code>:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;io.micrometer&lt;/groupId&gt;
 &lt;artifactId&gt;micrometer-registry-prometheus&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
Rebuild and start the application and navigate our browser to <code>http://localhost:8080/actuator</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-4.png" alt="spring boot monitor actuator prometheus">
This will generate a new endpoint - <code>/actuator/prometheus</code>. Opening it, you will see data formatted specific for Prometheus:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-5.png" alt="spring boot monitor actuator prometheus data">
<h2 id="prometheus">Prometheus</h2>
Prometheus is a time-series database that stores our metric data by pulling it (using a built-in data scraper) periodically over HTTP. The intervals between pulls can be configured, of course, and we have to provide the URL to pull from. It also has a simple user interface where we can visualize/query on all of the collected metrics.
Let's configure Prometheus, and more precisely the scrape interval, the targets, etc. To do that, we'll be using the <code>prometheus.yml</code> file:
<pre><code class="hljs">global:
 scrape_interval: 10s

scrape_configs:
 - job_name: &#x27;spring_micrometer&#x27;
 metrics_path: &#x27;/actuator/prometheus&#x27;
 scrape_interval: 5s
 static_configs:
 - targets: [&#x27;192.168.2.8:8080&#x27;]
</code></pre>
As you can see, we have a <code>scrape_configs</code> root key where we can define a list of jobs and specify the URL, metrics path, and the interval. If you'd like to read more about Prometheus configurations, feel free to visit the <a rel="nofollow noopener" target="_blank" href="https://prometheus.io/docs/prometheus/latest/configuration/configuration/">official documentation</a>.
Note: Since we are using Docker to run Prometheus, it will be running in a Docker network that won't understand <code>localhost/120.0.01</code>, as you might expect. Since our app is running on <code>localhost</code>, and for the Docker container, <code>localhost</code> means its own network, we have to specify our system IP in place of it.
So instead of using <code>locahost:8080</code>, <code>192.168.2.8:8080</code> is used where <code>192.168.2.8</code> is my PC IP at the moment.
To check your system IP you can run <code>ipconfig</code> or <code>ifconfig</code> in your terminal, depending upon your OS.
Now, we can run Prometheus using the Docker command:
<pre><code class="hljs">$ docker run -d -p 9090:9090 -v &lt;path-to-prometheus.yml&gt;:/etc/prometheus/prometheus.yml prom/prometheus
</code></pre>
<code>&lt;path-to-prometheus.yml&gt;</code> is where your own <code>prometheus.yml</code> is starting from the root. For an example, this works on my local Windows PC:
<pre><code class="hljs">$ docker run -d -p 9090:9090 -v $PWD/prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus
</code></pre>
To see Prometheus dashboard, navigate your browser to <a rel="nofollow noopener" target="_blank" href="http://localhost:9090">http://localhost:9090</a>:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-6.png" alt="prometheus dashboard">
To check if Prometheus is actually listening to the Spring app, you can go to the <code>/targets</code> endpoint:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-7.png" alt="monitor prometheus target">
Let's go back to the home page and select a metric from the list and click Execute:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-8.png" alt="monitor metric from the list">
<h3 id="prometheusquerylanguagepromql">Prometheus Query Language - PromQL</h3>
Another thing to note is - Prometheus has its own query language called PromQL. It allows the user to select and aggregate time series data in real-time, storing it either in graph or tabular format. Alternatively, you can feed it to an external API through HTTP.
If you'd like to read more about PromQL, the <a rel="nofollow noopener" target="_blank" href="https://prometheus.io/docs/prometheus/latest/querying/basics/">official documentation</a> covers it quite nicely.
<h2 id="grafana">Grafana</h2>
While Prometheus does provide some crude visualization, Grafana offers a rich UI where you can build up custom graphs quickly and create a dashboard out of many graphs in no time. You can also import many community built dashboards for free and get going.
Grafana can pull data from various data sources like Prometheus, <a rel="nofollow noopener" target="_blank" href="https://www.elastic.co/">Elasticsearch</a>, <a rel="nofollow noopener" target="_blank" href="https://www.influxdata.com/">InfluxDB</a>, etc. It also allows you to set rule-based alerts, which then can notify you over Slack, Email, HipChat, and similar.
Let's start off by running Grafana using Docker:
<pre><code class="hljs">$ docker run -d -p 3000:3000 grafana/grafana
</code></pre>
If you visit <code>http://localhost:3000</code>, you will be redirected to a login page:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-9.png" alt="grafana login page">
The default username is <code>admin</code> and the default password is <code>admin</code>. You can change these in the next step, which is highly recommended:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-10.png" alt="grafana dashboard">
Since Grafana works with many data sources, we need to define which one we're relying on. Select Prometheus as your data source:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-11.png" alt="grafana datasource">
Now, add the URL that Prometheus is running on, in our case <code>http://localhost:9090</code> and select Access to be through a browser.
At this point, we can save and test to see if the data source is working correctly:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-12.png" alt="grafana datasource update">
As previously said, Grafana has a ton of pre-built <a rel="nofollow noopener" target="_blank" href="https://grafana.com/grafana/dashboards">dashboards</a>. For Spring Boot projects, <a rel="nofollow noopener" target="_blank" href="https://grafana.com/grafana/dashboards/4701">the JVM dashboard</a> is popular:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-13.png" alt="grafana datasource import">
Input the URL for the dashboard, select &quot;Already created Prometheus datasource&quot; and then click Import:
<img src="https://stackabuse.s3.amazonaws.com/media/monitoring-spring-boot-apps-with-micrometer-prometheus-and-grafana-14.png" alt="grafana datasource jvm">
<h2 id="conclusion">Conclusion</h2>
Monitoring an application's health and metrics helps us manage it better, notice unoptimized behavior, and better understand its performance. This especially holds true when we're developing a system with many microservices, where monitoring each service can prove to be crucial when it comes to maintaining our system.
Based on this information, we can draw conclusions and decide which microservice needs to scale if further performance improvements can't be achieved with the current setup.
In this article, we used Micrometer to reformat the metrics data provided by Spring Boot Actuator and expose it in a new endpoint. This data was then regularly pulled and stored by Prometheus, which is a time-series database. Ultimately, we've used Grafana to visualize this information with a user-friendly dashboard.
As always, the code for the examples used in this article can be found on <a rel="nofollow noopener" target="_blank" href="https://github.com/StackAbuse/microservices-monitoring">GitHub</a>.

Dhananjay Singh

Monitoring an app's health helps us manage it and improve optimization and performance. In this article, we'll be using Micrometer, Prometheus, and Grafana to closely monitor a Spring Boot application.

Monitoring Spring Boot Apps with Micrometer, Prometheus, and Grafana

PyTorch, alongside Tensorflow, is an extremely popular deep learning library for Python. In this article, we'll cover one of the basic tasks in machine learning - classification.

Introduction to PyTorch for Classification

<h2 id="introduction">Introduction</h2>
In this article, we are going to a build simple app to serve static files like HTML files, CSS files, and images using <a rel="nofollow noopener" target="_blank" href="https://nodejs.org/en/">Node.js</a> and <a rel="nofollow noopener" target="_blank" href="https://expressjs.com/">Express</a>.
<h2 id="configuringtheprojectandinstallingexpress">Configuring the Project and Installing Express</h2>
To get started, let's create a new Node.js project by running the <code>init</code> command in a new folder:
<pre><code class="hljs">$ npm init
</code></pre>
Fill the requested information to your requirements or just set the default values by leaving each line blank.
Now we can install the Express framework by running:
<pre><code class="hljs">$ npm install --save express
</code></pre>
We are all set, let's start coding!
<h2 id="servingfileswithexpress">Serving Files with Express</h2>
There are two ways to serve static files using Express:
<ul>
<li>Serving a single file by configuring a path to the resource</li>
<li>Setting a public directory in which all files are accessible</li>
</ul>
We'll go over each of these methods in the next two sections.
<h3 id="servingasinglefile">Serving a Single File</h3>
Consider a scenario when we want to create a simple landing page that consists of 3 HTML documents (<code>home.html</code>, <code>contact.html</code>, and <code>about.html</code>), and we want to serve these files to the user.
Let's assume that the user visits the root path (<code>http://localhost:3000</code>). In that case, we want to serve the <code>home.html</code> file. Similarly, if the user visits the <code>/contacts</code> or <code>/about</code> paths, we want to serve the <code>contact.html</code> and <code>about.html</code> files, respectively.
To implement this, let's create a <code>landing-page.js</code> file and import the Express library:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
</code></pre>
Then, we'll create the Express app:
<pre><code class="hljs">const app = express();
</code></pre>
Then let's define the port on which our server will be running, which we'll use later when we actually run the server:
<pre><code class="hljs">const port = 3000;
</code></pre>
Since we are sending a single file, we won't include links to any CSS or script files within those HTML files unless they are hosted in a different location, like a <a rel="nofollow noopener" target="_blank" hre="https://en.wikipedia.org/wiki/Content_delivery_network">CDN</a>, for example.
We'll handle serving these files together in the next section, so for now, let's stick with three very simple, bare-bone HTML files:
home.html:
<pre><code class="hljs">&lt;body&gt;
 &lt;h1&gt;Home&lt;/h1&gt;
&lt;/body&gt;
</code></pre>
contact.html:
<pre><code class="hljs">&lt;body&gt;
 &lt;h1&gt;Contact&lt;/h1&gt;
&lt;/body&gt;
</code></pre>
about.html:
<pre><code class="hljs">&lt;body&gt;
 &lt;h1&gt;About Us&lt;/h1&gt;
&lt;/body&gt;
</code></pre>
Now let's go back and edit our <code>landing-page.js</code> file to send files corresponding to the paths the user visits, such as sending the <code>home.html</code> file when the user visits the root path.
We can use the <code>res.sendFile()</code> method to serve a file within a response:
<pre><code class="hljs">app.get(&#x27;/&#x27;, (req, res) =&gt; {
 res.sendFile(&#x27;./landing-page/home.html&#x27;, { root: __dirname });
});
</code></pre>
For security reasons, it's best to use a static path for <code>res.sendFile()</code>, as shown above. If you're ever taking user input that affects the file path, be very careful to prevent the user from being able to manipulate the file path and thus allowing them to retrieve private files.
In our case, we're setting the root for where the relative path is from by passing the <code>root</code> parameter to the method. Note that, we have passed <code>__dirname</code>, which is a Node.js global variable to the path of currently running file.
We can use the same method to serve our other files, <code>contact.html</code> and <code>about.html</code>, as well:
<pre><code class="hljs">app.get(&#x27;/about&#x27;, (req, res) =&gt; {
 res.sendFile(&#x27;./landing-page/about.html&#x27;, { root: __dirname });
});

app.get(&#x27;/contact&#x27;, (req, res) =&gt; {
 res.sendFile(&#x27;./landing-page/contact.html&#x27;, { root: __dirname });
});
</code></pre>
Now that our application is ready to go, let's start the server and listen to the port we set earlier:
<pre><code class="hljs">app.listen(port, () =&gt; console.log(`listening on port ${port}!`));
</code></pre>
And run our app by executing:
<pre><code class="hljs">$ node landing-page.js
</code></pre>
Open your browser and visit any of the mapped paths and you should be greeted with the HTML file(s):
<img src="https://stackabuse.s3.amazonaws.com/media/serving-static-files-with-node-and-express-1.png" alt="serving static html files with node">
<h3 id="settingupapublicdirectory">Setting up a Public Directory</h3>
The second method of serving static files is to set up a public directory. Unlike sending a file through the HTTP response, where only a single file can be served, all files inside our specified folder will be available for users.
Let's create another file, called <code>server.js</code>, and set the folder with our three HTML documents to be a public directory:
<pre><code class="hljs">const express = require(&#x27;express&#x27;);
const app = express();
const port = 3000;

// Setting up the public directory
app.use(express.static(&#x27;landing-page&#x27;));

app.listen(port, () =&gt; console.log(`listening on port ${port}!`));
</code></pre>
Making a directory public is as easy as using the <code>app.use()</code> and <code>express.static()</code> methods.
Let's run our app again and verify that it's working:
<pre><code class="hljs">$ node server.js
</code></pre>
Open your browser and visit any of the mapped paths and you should be greeted with the HTML files, just like last time. Keep in mind that this time, the root path is not mapped to the <code>home.html</code> file, but rather the <code>http://localhost:3000/home.html</code>:
<img src="https://stackabuse.s3.amazonaws.com/media/serving-static-files-with-node-and-express-2.JPG" alt="serving directories with node">
Also, you can set a prefix to the path to access your public directory by passing the prefix as the first parameter:
<pre><code class="hljs">app.use(&#x27;/public&#x27;, express.static(&#x27;landing-page&#x27;));
</code></pre>
Now, the files are situated on another path. For an example, <code>home.html</code> is now located at <code>http://localhost:3000/public/home.html</code>.
Unlike the first method where you'd hit <code>/about</code> and <code>about.html</code> would be served, note that you have to use the full file name in order to retrieve the file here - <code>/about.html</code>, for an example.
This allows us to host other files such as CSS, JavaScript files, and images as well.
For example, if there is a cat image on your public folder called <code>cat.png</code>, the server will be serving it on <code>http://localhost:3000/public/cat.png</code> depending on your configuration and you can easily call it via an HTML page and display it.
If you are planning to host a landing page like this, most probably it could be a combination of both methods that we discussed above. You can use a response to send a single HTML file and a public directory to host other static assets such as CSS files, JS scripts, and images.
<h2 id="conclusion">Conclusion</h2>
The source code of this project is available on <a rel="nofollow noopener" target="_blank" href="https://github.com/jkasun/server-static-files-with-express">GitHub</a> as usual. Use this to compare your code if you ever got stuck along the tutorial.
Happy Coding!

Janith Kasun

In this article, we'll be building a simple app to serve static files like HTML files, CSS files and images using Node.js and Express.

Serving Static Files with Node and Express.js

Dunja Spasić

Shell Sort is an advanced sorting algorithm. It's considered to be a generalization of Insertion Sort and works by comparing elements far apart. In this article, we'll be diving into the theory and implementation of Shell Sort.

Shell Sort in Java

Olivera Popović

MySQL is the most widely used RDDBMS in the world. In this article, we'll guide you through the installation process and set up on Windows.