DEV Community: Peter Shekindo

How to appropriately git stash

Peter Shekindo — Mon, 12 Sep 2022 05:32:06 +0000

Imagine these scenarios

You want to safely switch between branches without worrying about current untracked files or the state of the working directory. Well, you don't need to commit changes every time before switching between branches.
Imagine temporarily committing on the current branch, switching to a different branch, cherry-picking your commit, and then removing it from where it was originally created. 🥵🤢
I am not done with what I am currently working on and there comes an urgent update that needs to be implemented in a production environment.

🤔 should I just commit the unfinished updates and move to the production branch?

🤔 which commit message should I write, “Just committed this for the sake of not losing my updates”?

That’s where git stash becomes your Swiss knife to support you in multitasking and constantly being able to shift and work on something different without breaking a sweat.

Git stash is a powerful tool to stash or secretly save changes made on any tracked files without the need to commit them, which allows retrieving or reapplying those changes at any point in time regardless of the current branch in use.

So how do you use it?

To stash the current changes just use the git stash command as shown below and your changes are safely stashed.

$ git stash

Note: git stash works only for tracked changes. So for example you have added a new file to your project, any changes made to that file are untracked changes. To allow them to be tracked you need to stage them with git add command.

To confirm if all the files are tracked, you can run git status command as shown below.

$ git status

The output should look like so.

As seen above there is a list of files that are not staged yet in /number_trivia.dart directory and an untracked file in /sampleNumberTrivia.dart.

To allow files to be tracked, we use git add command followed by a specific file name you would like to start tracking, or followed by a full stop “.” if you would like to track all untracked files.

This adds tracking to a specific file

$ git add <file name>

This adds tracking to all untracked files

$ git add .

So if we run the git status command it should look different now.

To view a list of all stashed changes you simply run the git stash list command as shown below.

$ git stash list

The output should be something like this:

But hey, how can I remember which stashed changes contain what.? Though the files are named with different names as stash{0}, stash{1} ……. Stash{n} but this naming format is not helpful enough.

Stash your changes with a message ✍️

To make it simple it is possible to stash changes with name or message. I usually stash my changes with a message.

Run the git stash -m command as shown below with a message.

$ git stash -m “stashing message”

And the output should be like so.

So if we list the stashed changes by using git stash list command now, the output should look as below

Notice a message on index “stash@{0}”. This makes it simple to understand which stash contains what.

How git stash works

Before we start looking at how to retrieve a stashed record, we need to understand how stashing works.

Consider the following diagram

Every time you stash changes, git tracks the stash records in a stack. Therefore, the latest stash is moved to the top of the stack which is identified with the index 0 (stash@{0}). Storing the stashes in a stack plays a key role when using other functionality when using apply and pop options to retrieve a stash.

How to retrieve stashed records?

There are two ways you can retrieve stashed changes

Pop
Apply

pop

With pop, you retrieve changes to a current branch and remove the stash record from the stash list.

We use git stash pop command to pop the stashed record. This can be used in two ways by specifying a targeted stash record or without specifying a targeted stash record

$ git stash pop

The above command will pop Stash@{0} from the stash record and apply it to a current branch since stashes are stored in stack format. This can be seen in the below example

To pop a specific record from a stash list we need to specify the record name (index) defined at the end of the git stash pop command.

$ git stash pop <name index>

This can be seen in the diagram below.

Apply

Git Apply command works almost similar to the git pop command with the only difference being that using pop retrieves and deletes the record from the stash list while git apply retrieves and retains the record from the stash list.

Also apply can be used in two ways. Git apply with a specific target record or without specifying a targeted record.

Without specifying a targeted record, git will retrieve stash@{0} index which is the last stashed record.

Apply without a targeted record

$ git stash apply

Apply a specific record

$ git stash apply <name index>

Let us take a break here for today, on the next section we will go through the rest of the concepts which are.

Removing git stash

Most of the time we keep on stashing records and re-applying them later without necessarily removing them from the stash list. To remove git stash we use the drop option. as in pop and apply, if you don't specify which record you want to drop from the list, it will remove the last stashed record stash@{0}

$ git stash drop

to specify which record you would like to remove from a stash list we use

$ git stash drop <name index>

In case you would like to wipe and clean all the stashed records from the stack at once, you can use the clear option.

$ git stash clear

This is all I have for you today, I hope you find this article useful. until next time "keep reading keep growing"

This article has been prepared on behalf of ClickPesa. For many articles like this just click this --> ClickPesa on hasnode, ClickPesa on dev.to and ClickPesa on medium.

How to implement logging in your REST service by using Elasticsearch: PART 2.B

Peter Shekindo — Mon, 08 Aug 2022 11:37:00 +0000

This is the last section of this article series which explains how to implement logging in REST services using Elasticsearch.

Before continuing with this section, I advise you to go through the previous sections first in case you did not go through them. Just click the links bellow

How to implement logging in your REST service by using Elasticsearch - Part 1
How to implement logging in your REST service by using Elasticsearch — Part 2

In this last section, “_I promise it is the last 😉 _”. We will finish up strong 💪 with the final three steps.

Step-4 Install and configure Kibana.

Step-5 Install and configure Logstash

Step-6 Exploring logs in Kibana dashboard

Step-4 Install and configure Kibana.

According to the official documentation, you should install Kibana only after installing Elasticsearch. Installing in this order ensures to manage dependency for each component.

Because you’ve already added the Elastic package source in the previous step, you can just install the remaining components of the Elastic Stack using apt:

$ sudo apt install kibana

Then run the command below to enable and start the Kibana service:

$ sudo systemctl enable kibana
$ sudo systemctl start kibana

Because Kibana is configured to only listen on localhost, we must set up a reverse proxy to allow external access to it. We will use Nginx for this purpose, which should already be installed on your server. You may use any web server of your choice.

In this article, we will focus on setup Nginx to use reverse proxy only, but for more on how to configure a reverse proxy, load balancing, buffering and caching with Nginx, click the following link.

Nginx HTTP proxying.

First, use the openssl command to create an administrative Kibana user which you’ll use to access the Kibana web portal. As an example we will name this account kibanaadmin, but to ensure greater security we recommend that you choose a non-standard name for your user that would be difficult to guess.

The following command will create the administrative Kibana user and password, and store them in the htpasswd.users file. You will configure Nginx to require this username and password and read this file momentarily:

$ echo "kibanaadmin:`openssl passwd -apr1`" | sudo tee -a /etc/nginx/htpasswd.users

Enter and confirm a password at the prompt. Remember or take note of this login, as you will need it to access the Kibana web portal.

Next, we will create an Nginx server block file. As an example, we will refer to this file as example.com, although you may find it helpful to give yours a more descriptive name. For instance, if you have a FQDN and DNS records set up for this server, you could name this file after your FQDN:

$ sudo nano /etc/nginx/sites-available/example.com

Add the following code block into the file, being sure to update example.com to match your server’s FQDN or public IP address. This code configures Nginx to direct your server’s HTTP traffic to the Kibana application, which is listening on localhost:5601. Additionally, it configures Nginx to read the htpasswd.users file and require basic authentication.

Delete everything in the file and paste the content below. Note only do this if it is your first time to do this, if you have already configured the file you may want to update as per content below.

server {
    listen 80;
    server_name example.com;
    auth_basic "Restricted Access";
    auth_basic_user_file /etc/nginx/htpasswd.users;
    location / {
        proxy_pass http://localhost:5601;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}

When you’re finished, save and close the file.

Next, enable the new configuration by creating a symbolic link to the sites-enabled directory. If you already created a server block file with the same name in the Nginx prerequisite, you do not need to run this command:

$ sudo ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/example.com

Then check the configuration for syntax errors:

$ sudo nginx -t

If any errors are reported in your output, go back and double-check that the content you placed in your configuration file was added correctly. Once you see syntax is ok in the output, go ahead and restart the Nginx service:

$ sudo systemctl restart nginx

Also, you should have a UFW firewall enabled. To allow connections to Nginx, we can adjust the rules by typing:

$ sudo ufw allow 'Nginx Full'

This will allow both HTTP and HTTPS traffic through the firewall. You may use 'Nginx HTTP'for HTTP and 'Nginx HTTPS' for HTTPS.

Kibana is now accessible via your FQDN or the public IP address of your Elastic Stack server. You can check the Kibana server’s status page by navigating to the following address and entering your login credentials when prompted:

http://your_serve_IP/status

This status page displays information about the server’s resource usage and lists the installed plugins.

Now that the Kibana dashboard is configured, let’s install the next component: Logstash.

Step-5 Install and configure Logstash

Logstash is used to process our saved log files. It collects data from different sources, transform it into a common format, and exports it to another database.

Install Logstash with this command:

$ sudo apt install logstash

create a configuration file called input.conf, where you will set up your log source input:

sudo nano /etc/logstash/conf.d/input.conf

Insert the following input configuration. This specifies a source file that holds all logs generated in the system. As seen in the script path => "specify the path to where your logfile is located" this specifies log file path, start_position => "beginning"this specifies Logstash should read the file from the beginning.

input {
  file {
         path => "specify the path to where your logfile is located"
    start_position => "beginning"
    sincedb_path => "/dev/null"
  }
}

Save and close the file.

Next, create a configuration file called 30-elasticsearch-output.conf:

sudo nano /etc/logstash/conf.d/30-elasticsearch-output.conf

Insert the following output configuration. Essentially, this output configures Logstash to store the logged data in Elasticsearch, which is running at localhost:9200. Notice the Index => filebeat this will help us to create index pattern in the Kibana dashboard which will act as our log reference to where our logs referred from

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    Index => filebeat
  }

Save and close the file.

Test your Logstash configuration with this command:

sudo -u logstash /usr/share/logstash/bin/logstash --path.settings /etc/logstash -t

If there are no syntax errors, your output will display Config Validation Result: OK. Exiting Logstash after a few seconds. If you don’t see this in your output, check for any errors noted in your output and update your configuration to correct them. Note that you will receive warnings from OpenJDK, but they should not cause any problems and can be ignored.

If your configuration test is successful, start and enable Logstash to put the configuration changes into effect:

$ sudo systemctl start logstash
$ sudo systemctl enable logstash

Now that Logstash is running correctly and is fully configured, let’s start to review logs in Kibana dashboard.

Step-6 Exploring logs in Kibana dashboard

Let’s return to the Kibana web interface that we installed earlier.

In a web browser, go to the FQDN or public IP address of your Elastic Stack server. If your session has been interrupted, you will need to re-enter the credentials you defined in Kibana configuration steps. Once you have logged in, you should receive the Kibana homepage:

Click the Discover link in the left-hand navigation bar (you may have to click the Expand icon at the very bottom left to see the navigation menu items). On the Discover page, select the predefined filebeat-* index pattern to see logged data. By default, this will show you all of the log data over the last 15 minutes. You will see a histogram with log events, and some log messages below:

In this tutorial, you’ve learned how to install and configure the Elastic Stack to collect and analyze system logs. Remember that you can send just about any type of log or indexed data to Logstash, but the data becomes even more useful if it is parsed and structured with a Logstash filter, as this transforms the data into a consistent format that can be read easily by Elasticsearch.

To learn more about ELSK stack and other concept, you may visit this link digital ocean community.

This article has been prepared on behalf of ClickPesa. For many article like this just click this licks ClickPesa on hasnode, ClickPesa on dev.to and ClickPesa on medium.

How to implement logging in your REST service by using Elasticsearch - PART 2

Peter Shekindo — Wed, 13 Jul 2022 03:46:35 +0000

How to implement logging in your REST service by using Elasticsearch - PART 2

Note:
This article is the second part of How to implement logging in your REST service by using Elasticsearch article series. Click the below link for part 1 of this series, or if you have already gone through that then you are good to proceed with part 2.

How to implement logging in your REST service by using Elasticsearch - PART 1

In part 1 of this article series, I explained the introduction to the ELK stack and how it can be used to implement logging in your REST service. You can find the first section of this series in the following links medium, dev, and hashnode. In this section, we will discuss how we can install, configure and use the ELK stack.

For logging purposes, Elasticsearch comes with two other tools Kibana and Logstash. Together they form the ELK stack as introduced in part one of this article.
To avoid confusion and reading fatigue, I will divide this second part into two sections as well

Part 2.A: Install and configure Elasticsearch

Part 2.B: Install and configure Kibana and Logstash as well as how to use the ELK stack

Logging Process with ELK stack

Part 2.A: Install and configure Elasticsearch

Initially, we need to download Elasticsearch, Kibana, and Logstash. Below are the links where you may download these tools. Currently, I am using version 8.3.1 in a Linux environment, but the version might vary for different environments and times. Also in this article, we will be using APT (Advanced Package Tool) which is a Linux installation package manager to download and install all tools.

Tool	Files (.zip)	apt-get installation	yum	Docker image
Kibana	https://artifacts.elastic.co/downloads/kibana/kibana-8.3.1-linux-x86_64.tar.gz	https://www.elastic.co/guide/en/kibana/8.3/deb.html#deb-repo	https://www.elastic.co/guide/en/kibana/8.3/rpm.html#rpm-repo	https://www.elastic.co/guide/en/kibana/current/docker.html
Logstash	https://artifacts.elastic.co/downloads/logstash/logstash-8.3.1-linux-x86_64.tar.gz	https://www.elastic.co/guide/en/logstash/8.3/installing-logstash.html#_apt	https://www.elastic.co/guide/en/logstash/8.3/installing-logstash.html#_yum	https://www.elastic.co/guide/en/logstash/current/docker.html
Elasticsearch	https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.3.1-linux-x86_64.tar.gz	https://www.elastic.co/guide/en/elasticsearch/reference/8.3/deb.html#deb-repo	https://www.elastic.co/guide/en/elasticsearch/reference/8.3/rpm.html#rpm-repo	https://www.elastic.co/guide/en/elasticsearch/reference/current/docker.html

Note:
In this article, we mainly focus on accessing logs logged in an external file or files. This means you need to implement an external logging service to a file or files in the REST architecture of your choice. Thus all logs should be accessed from a specific file or files.

Steps 1 - Installing Elasticsearch

To begin, we need to configure the Ubuntu package repository by adding Elastic’s package source list in order to download and install Elasticsearch. This is not configured by default, so we need to do it manually.

Note:
All of the packages are signed with the Elasticsearch public GPG key in order to protect your system from package spoofing. Packages authenticated using a key are considered secured by the downloading manager.

a. Open the terminal and use the cURL command-line tool for transferring data with URL, to import the Elasticsearch public GPG key into APT. We are also using the arguments -fsSL to silence all progress and possible errors (except for a server failure) and to allow cURL to make a request on a new location if redirected:

$ curl -fsSL https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

b. add the Elastic source list to the sources.list.d directory, where APT will look for new sources:

$ echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee -a /etc/apt/sources.list.d/elastic-7.x.list

c. update your package lists so APT will read the new Elastic source:

$ sudo apt update

d. Use this command to install Elasticsearch

$ sudo apt install elasticsearch

If you have reached this far without any error, that means Elasticsearch is now installed and ready to be configured. 🎉

Steps 2 - Configuringing Elasticsearch

All Elastic search configuration goes into elasticsearch.yml

a. Use the command to access elasticsearch.yml file

$ sudo nano /etc/elasticsearch/elasticsearch.yml

There is a lot you can configure in Elasticsearch such as cluster, node, path, memory, network, discovery, and gateway. Most of these configurations are already preconfigured in the file but you can change them as you see fit.
For the sake of this tutorial, we will only change the network host configuration to allow single server access.

Elasticsearch listens for traffic from everywhere on port 9200. For this reason You may want to restrict outside access to your Elasticsearch instance to prevent outsiders from reading your data or shutting down your Elasticsearch cluster through its [REST API]

In order to accomplish this, find the line that specifies network.host, uncomment it, and replace its value with custom IP address like this:

. . .
# ------------------------Network -----------------------------------
#
# Set the bind address to a specific IP (IPv4 or IPv6):
#
network.host: custom IP address
. . .

b. If you accessed the configuration file by nano, use the following key combination to save and close the file CTRL+X or ⌘ + X in Macintosh, followed by Y and then ENTER.

Steps 3 - Configuring Elasticsearch

We use systemctl command to start Elasticsearch service, this will allow Elasticsearch to initiate properly otherwise it will run into error and fail to start.

a. Open terminal and run command.

$ sudo systemctl start elasticsearch

b. You can also enable Elasticsearch to automatically run on every system boot.

$ sudo systemctl enable elasticsearch

c. Run the following command to test your Elasticsearch. note, as for me Elasticsearch is running on localhost:9200. you may want to specify which IP:Port address your Elasticsearch is using upon.

$ curl -X GET "localhost:9200"

If every thing went well, you will see a response showing some basic information about your local node, similar to this:

Output
{
  "name" : "Elasticsearch",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "qqhFHPigQ9e2lk-a7AvLNQ",
  "version" : {
    "number" : "7.7.1",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "ef48eb35cf30adf4db14086e8aabd07ef6fb113f",
    "build_date" : "2020-03-26T06:34:37.794943Z",
    "build_snapshot" : false,
    "lucene_version" : "8.5.1",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

Now that Elasticsearch is up and running, in the next section which is Part 2.B of this article series, we will install Kibana, and Logstash and test our Logging configuration.

Just incase you dont know, there are many more article like this at ClickPesa on hasnode, ClickPesa on dev.to and ClickPesa on medium. You will thank me later.

How to implement logging in your REST service by using Elasticsearch - PART 2

Peter Shekindo — Mon, 11 Jul 2022 16:51:08 +0000

How to implement logging in your REST service by using Elasticsearch - PART 2

In part 1 of this article series I explained the introduction to the ELK stack and how it can be used to implement logging in your REST service. You can find the first section of this series in the following links medium, dev, and hashnode. In this section, we will discuss how we can install, configure and use the ELK stack.

Part 2.A: Install and configure Elasticsearch

Part 2.B: Install and configure Kibana and Logstash as well as how to use the ELK stack

Logging Process with ELK stack

Part 2.A: Install and configure Elasticsearch

Tool	Files (.zip)	apt-get installation	yum	Docker image
Kibana	https://artifacts.elastic.co/downloads/kibana/kibana-8.3.1-linux-x86_64.tar.gz	https://www.elastic.co/guide/en/kibana/8.3/deb.html#deb-repo	https://www.elastic.co/guide/en/kibana/8.3/rpm.html#rpm-repo	https://www.elastic.co/guide/en/kibana/current/docker.html
Logstash	https://artifacts.elastic.co/downloads/logstash/logstash-8.3.1-linux-x86_64.tar.gz	https://www.elastic.co/guide/en/logstash/8.3/installing-logstash.html#_apt	https://www.elastic.co/guide/en/logstash/8.3/installing-logstash.html#_yum	https://www.elastic.co/guide/en/logstash/current/docker.html
Elasticsearch	https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-8.3.1-linux-x86_64.tar.gz	https://www.elastic.co/guide/en/elasticsearch/reference/8.3/deb.html#deb-repo	https://www.elastic.co/guide/en/elasticsearch/reference/8.3/rpm.html#rpm-repo	https://www.elastic.co/guide/en/elasticsearch/reference/current/docker.html

Steps 1 - Installing Elasticsearch

b. add the Elastic source list to the sources.list.d directory, where APT will look for new sources:

c. update your package lists so APT will read the new Elastic source:

d. Use this command to install Elasticsearch

If you have reached this far without any error, that means Elasticsearch is now installed and ready to be configured. 🎉

Steps 2 - Configuringing Elasticsearch

All Elastic search configuration goes into elasticsearch.yml

a. Use the command to access elasticsearch.yml file

In order to accomplish this, find the line that specifies network.host, uncomment it, and replace its value with custom IP address like this:

src="https://carbon.now.sh/embed?bg=rgba%28171%2C+184%2C+195%2C+1%29&t=seti&wt=none&l=auto&width=680&ds=true&dsyoff=20px&dsblur=68px&wc=true&wa=true&pv=56px&ph=56px&ln=false&fl=1&fm=Hack&fs=14px&lh=133%25&si=false&es=1x&wm=false&code=.%2520.%2520.%250A%2523%2520-----------------Network%2520-----------------%250A%2523%250A%2523%2520Set%2520the%2520bind%2520address%2520to%2520a%2520specific%2520IP%2520%28IPv4%2520or%2520IPv6%29%253A%250A%2523%250Anetwork.host%253A%2520custom%2520IP%2520address%250A.%2520.%2520."
style="width: 600px; height: 330px; border:0; transform: scale(1); overflow:hidden;"
sandbox="allow-scripts allow-same-origin">

b. If you accessed the configuration file by nano, use the following key combination to save and close the file CTRL+X or ⌘ + X in Macintosh, followed by Y and then ENTER.

Steps 3 - Configuring Elasticsearch

We use systemctl command to start Elasticsearch service, this will allow Elasticsearch to initiate properly otherwise it will run into error and fail to start.

a. Open terminal and run command.

b. You can also enable Elasticsearch to automatically run on every system boot.

If every thing went well, you will see a response showing some basic information about your local node, similar to this:

src="https://carbon.now.sh/embed?bg=rgba%28171%2C+184%2C+195%2C+1%29&t=seti&wt=none&l=application%2Fx-sh&width=680&ds=true&dsyoff=20px&dsblur=68px&wc=true&wa=true&pv=56px&ph=56px&ln=false&fl=1&fm=Hack&fs=14px&lh=133%25&si=false&es=1x&wm=false&code=%250A%257B%250A%2520%2520%2522name%2522%2520%253A%2520%2522Elasticsearch%2522%252C%250A%2520%2520%2522cluster_name%2522%2520%253A%2520%2522elasticsearch%2522%252C%250A%2520%2520%2522cluster_uuid%2522%2520%253A%2520%2522qqhFHPigQ9e2lk-a7AvLNQ%2522%252C%250A%2520%2520%2522version%2522%2520%253A%2520%257B%250A%2520%2520%2520%2520%2522number%2522%2520%253A%2520%25227.7.1%2522%252C%250A%2520%2520%2520%2520%2522build_flavor%2522%2520%253A%2520%2522default%2522%252C%250A%2520%2520%2520%2520%2522build_type%2522%2520%253A%2520%2522deb%2522%252C%250A%2520%2520%2520%2520%2522build_hash%2522%2520%253A%2520%2522ef48eb35cf30adf4db14086e8aabd07ef6fb113f%2522%252C%250A%2520%2520%2520%2520%2522build_date%2522%2520%253A%2520%25222020-03-26T06%253A34%253A37.794943Z%2522%252C%250A%2520%2520%2520%2520%2522build_snapshot%2522%2520%253A%2520false%252C%250A%2520%2520%2520%2520%2522lucene_version%2522%2520%253A%2520%25228.5.1%2522%252C%250A%2520%2520%2520%2520%2522minimum_wire_compatibility_version%2522%2520%253A%2520%25226.8.0%2522%252C%250A%2520%2520%2520%2520%2522minimum_index_compatibility_version%2522%2520%253A%2520%25226.0.0-beta1%2522%250A%2520%2520%257D%252C%250A%2520%2520%2522tagline%2522%2520%253A%2520%2522You%2520Know%252C%2520for%2520Search%2522%250A%257D%250A"
style="width: 600px; height: 580px; border:0; transform: scale(1); overflow:hidden;"
sandbox="allow-scripts allow-same-origin">

Now that Elasticsearch is up and running, in the next section which is Part 2.B of this article series, we will install Kibana, and Logstash and test our Logging configuration.

How to implement logging in your REST service by using Elasticsearch

Peter Shekindo — Mon, 30 May 2022 08:26:22 +0000

How to implement logging in your REST service by using Elasticsearch

This article consists of two sections. In part one we will focus on Logging as a service concept and introduction, in Part two, we will see how to set up, integrate Elasticsearch and its tools and how to access logs via Elastic search. Below are section categories.

Part 1

What is Logging?
What is a Log file
Types of logs
Elasticsearch
- What is Elasticsearch?
- What is ELK stack?

Part 2

Elasticsearch
- How to setup Elasticsearch
- How to integrate Elasticsearch into your REST service
- How to access logs in Elasticsearch
- Elasticsearch in relation to REST API
- Benefits of using Elasticsearch?
Logging advantage
Conclusion

PART 1

What is Logging?

Is a process of collecting and processing any type of log files coming from any given source or location such as server services, applications, devices, etc.

What is a Logfile?

Is a file that contains records of either events or processes that are taking place in a system. This file may contain a status, warning, or any other intended information that explains what is going on in a system.

In various REST service architectures, there are several types of log files that can be implemented that define the type of information the file contains. Below are some of the log files.

General Purpose logs

This is a type of log file that contains general information such as the service port that a system is using or the current state of a service

Warning logs

These are logs intended to handle issues that are not fatal or disruptive. This usually denotes that the issue is not disruptive but it should be taken into consideration. (example: managed to save data in a DB but after multiple attempts)

Error logs

This contains information regarding unhandled issues that are fatal or disruptive. (Example: Failed to save data in a DB but all the validation passed and data is clear to be saved)

Debug logs

This contains information that helps us to debug the logic in case of an error or warning. These usually are intended for developers.

Verbose logs

These are the logs to provide insights about the behavior of the app, intended for operators and the support team.

Various REST Architectures support default logging services out of the box and they can be configured to be accessed without any third-party services. This is suitable while when you are interacting with small data sets and managing small to medium systems, monitoring extensive systems can become an issue. A solution to this is to add dedicated services to support your logging process. In this article, I will be walking you through how to implement logging on REST API with Elasticsearch covering deploying, managing, and analyzing logs.

What is Elasticsearch?

Elasticsearch is a distributed RESTful search and analytics engine capable of addressing a growing number of use cases. It centrally stores your data for lightning-fast search, fine‑tuned relevancy, and powerful analytics that scale with ease.

Elasticsearch consists of various tools that can be used alongside to support your demands. Explore more to see other tools that Elasticsearch offers.

What is ELK stack?

"ELK" is the acronym for three open source projects Elasticsearch, Logstash, and Kibana.

Elasticsearch

A distributed, free and open search and analytics engine for all types of data, including textual, numerical, geospatial, structured, and unstructured.
Logstash

A server‑side data processing pipeline that ingests data from multiple sources simultaneously, transforms it, and then sends it to a "stash" like Elasticsearch.
Kibana

Lets users visualize data with charts and graphs in Elasticsearch.

ELK stack workflow with Spring Boot logging service

This is all for this chapter regarding the introduction to logging as a service and tooling. In the next chapter, we will see how to implement the Elasticsearch on the REST service to manage and monitor logs.

Automating code review on commit

Peter Shekindo — Mon, 02 May 2022 10:20:33 +0000

HOW TO AUTOMATE CODE REVIEWS ON COMMITS

Imagine the hustle of spending hours on code review every day. Code review automation may save countless wasted efforts.

This Article may walk you through steps on how to add automated code reviews that may be executed during every code commit.

Codacy is one of the tools that may be used to achieve this.

Codacy is an automated code review tool that helps developers ship better software, faster. With Codacy, you get static analysis, cyclomatic complexity, duplication, and code unit test coverage changes in every commit and pull request.

Steps to integrate your project with Codacy

1. Sign up

You may use your Git provider such as GitHub, GitLab, or Bitbucket to sign up to Codacy. This links your Codacy user with your Git provider user, making it easier to add repositories to Codacy and invite your teammates.

2. Grant access

Codacy will request access to your Git provider and will require you to provide a few details regarding your organization. (this helps them on use case evaluation).

3. Choose organization

Now you will be required to join the organizations that contain your repositories

Note:

codacy name the organizations similar to your git repository user name.

Example If your repository is “github.com/Fruitsandvegies”. Then the name of your organization will be “Fruitsandvegies”.

4. Adding repository

By selecting the organization on step 3, codency will list all related repositories available. Select the “add” option to add the repository for review. Codancy will immediately set up everything so as to be ready to analyze on the next commit.

Note:

You can add the repository to Codancy only if you have permission to that repository.

5. Review result of the analysis

Select “Go to repository” once the analysis has completed reviewing the results.

Detailed analysis result

The initial analysis from Codancy will be based on the default configuration. Codacy provides tweaks to allow you to set up a custom configuration such as files to ignore, code pattern, and adjust quality settings.

Automating code review on commit

Peter Shekindo — Fri, 29 Apr 2022 12:37:24 +0000

HOW TO AUTOMATE CODE REVIEWS ON COMMITS

Imagine the hustle of spending hours on code review every day. Code review automation may save countless wasted efforts.

This Article may walk you through steps on how to add automated code reviews that may be executed during every code commit.

Codacy is one of the tools that may be used to achieve this.

Steps to integrate your project with Codacy

1. Sign up

2. Grant access

Codacy will request access to your Git provider and will require you to provide a few details regarding your organization. (this helps them on use case evaluation).

3. Choose organization

Now you will be required to join the organizations that contain your repositories

Note:

codacy name the organizations similar to your git repository user name.

Example If your repository is “github.com/Fruitsandvegies”. Then the name of your organization will be “Fruitsandvegies”.

4. Adding repository

Note:

You can add the repository to Codancy only if you have permission to that repository.

5. Review result of the analysis

Select “Go to repository” once the analysis has completed reviewing the results.

Detailed analysis result

Automating code review on commit

Peter Shekindo — Fri, 29 Apr 2022 06:45:01 +0000

HOW TO AUTOMATE CODE REVIEWS ON COMMITS

Imagine the hustle of spending 1- 4 hours on code review every day. Code review automation may save countless wasted efforts.

This Article may walk you through steps on how to add automated code reviews that may be executed during every code commit.

Codacy is one of the tools that may be used to achieve this.

Steps to integrate your project with Codacy

1. Sign up

2. Grant access

Codacy will request access to your Git provider and will require you to provide a few details regarding your organization. (this helps them on use case evaluation).

3. Choose organization

Now you will be required to join the organizations that contain your repositories

Note:

codacy name the organizations similar to your git repository user name.

Example If your repository is “github.com/Fruitsandvegies”. Then the name of your organization will be “Fruitsandvegies”.

4. Adding repository

Note:

You can add the repository to Codancy only if you have permission to that repository.

5. Review result of the analysis

Select “Go to repository” once the analysis has completed reviewing the results.

Detailed analysis result