{"componentChunkName":"component---src-templates-tag-js","path":"/tags/performance/","result":{"data":{"site":{"siteMetadata":{"title":"LoginRadius Blog"}},"allMarkdownRemark":{"totalCount":4,"edges":[{"node":{"fields":{"slug":"/engineering/tune-the-go-http-client-for-high-performance/"},"html":"

HTTP (hypertext transfer protocol) is a communication protocol that transfers data between client and server. HTTP requests are very essential to access resources from the same or remote server. In Golang, the net/http package comes with the default settings that we need to adjust according to our high-performance requirement.

\n

For setting up HTTP clients for making requests, most programming languages have different frameworks in place. We will take a hands-on approach in the coming sections to explore how HTTP requests can be made in Golang or Go, as I will refer to the language for the rest of the post.

\n

While working on the Golang projects, I realized that improper configuration of HTTP might crash your server anytime.

\n

In the time when I was working with HTTP Client, I Observed some problems and their solutions, listed below:

\n

Problem:1 Default Http Client

\n

The HTTP client does not contain the request timeout setting by default.\nIf you are using http.Get(URL) or &Client{} that uses the http.DefaultClient. DefaultClient has not timeout setting; it comes with no timeout

\n

Suppose the Rest API where you are making the request is broken, not sending the response back that keeps the connection open. More requests came, and open connection count will increase, Increasing server resources utilization, resulting in crashing your server when resource limits are reached.

\n

Solution: Don't use the default HTTP client, always specify the timeout in http.Client according to your use case

\n
var httpClient = &http.Client{\n  Timeout: time.Second * 10,\n}
\n

For the Rest API, it is recommended that timeout should not more than 10 seconds.\nIf the Requested resource is not responded to in 10 seconds, the HTTP connection will be canceled with net/http: request canceled (Client.Timeout exceeded ...) error.

\n

Problem:2 Default Http Transport

\n

By default, the Golang Http client performs the connection pooling. When the request completes, that connection remains open until the idle connection timeout (default is 90 seconds). If another request came, that uses the same established connection instead of creating a new connection, after the idle connection time, the connection will return to the pool.

\n

Using the connection pooling will keep less connection open and more requests will be served with minimal server resources.

\n

When we not defined transport in the http.Client, it uses the default transport Go HTTP Transport

\n

Default configuration of the HTTP Transport,

\n
var DefaultTransport RoundTripper = &Transport{\n\t...\n\tMaxIdleConns:          100,\n\tIdleConnTimeout:       90 * time.Second,\n\t...\n}\n\nconst DefaultMaxIdleConnsPerHost = 2
\n

MaxIdleConns is the connection pool size, and this is the maximum connection that can be open; its default value is 100 connections.

\n

There is problem with the default setting DefaultMaxIdleConnsPerHost with value of 2 connection,\nDefaultMaxIdleConnsPerHost is the number of connection can be allowed to open per host basic.\nMeans for any particular host out of 100 connection from the connection pool only two connection will be allocated to that host.

\n

With the more request came, it will process only two requests; other requests will wait for the connection to communicate with the host server and go in the TIME_WAIT state. As more request came, increase the connection to the TIME_WAIT state and increase the server resource utilization; at the limit, the server will crash.

\n

Solution: Don't use Default Transport and increase MaxIdleConnsPerHost

\n
t := http.DefaultTransport.(*http.Transport).Clone()\nt.MaxIdleConns = 100\nt.MaxConnsPerHost = 100\nt.MaxIdleConnsPerHost = 100\n\t\nhttpClient = &http.Client{\n  Timeout:   10 * time.Second,\n  Transport: t,\n}
\n

By increasing connection per host and the total number of idle connection, this will increase the performance and serve more request with minimal server resources.

\n

Connection pool size and connection per host count can be increased as per server resources and requirements.

\n

Conclusion

\n

In this article, we discussed the problems around the 'net/http' client default configurations. By changing some of the default settings of HTTP Client, we can achieve a High-performance HTTP client for production use. If you want to learn more about http, here is an interesting post on HTTP security headers If you like what you read, share your thoughts in the comment section.

\n","frontmatter":{"date":"January 12, 2021","updated_date":null,"title":"How to Use the HTTP Client in GO To Enhance Performance","tags":["Golang","HTTP","Performance"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/2aae63044134172737715b9d1801c174/58556/index.webp","srcSet":"/static/2aae63044134172737715b9d1801c174/61e93/index.webp 200w,\n/static/2aae63044134172737715b9d1801c174/1f5c5/index.webp 400w,\n/static/2aae63044134172737715b9d1801c174/58556/index.webp 800w,\n/static/2aae63044134172737715b9d1801c174/99238/index.webp 1200w,\n/static/2aae63044134172737715b9d1801c174/135cd/index.webp 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Mayank Agarwal","github":"mayankagrwal","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/speed-up-python-code/"},"html":"

A Few Ways to Speed Up Your Python Code

\n

Python is one of the most popular languages all over the world. Nowadays it is being used in competitive programming also because of its simple syntax and rich libraries. Most of us probably started coding with python. At first, everything goes simple and easy. But while solving a hard algorithmic problem, most of us suffer from Time Limit Exceeded. However, it is not a problem of python; it is the programmer's problem. I am not saying that language is not slow, but if a programmer writes an efficient programme, it will get Accepted for sure. Here are some tips to speed up your python programme.

\n

Use proper data structure

\n

Use of proper data structure has a significant effect on runtime. Python has list, tuple, set and dictionary as the built-in data structures. However, most of the people use the list in all cases. But it is not a right choice. Use proper data structures depending on your task. Especially use a tuple instead of a list. Because iterating over tuple is easier than iterating over a list.

\n

Decrease the use of for loop

\n

As for loop is dynamic in python, it takes more time than while loop. So, use while loop instead of for loop.

\n

Use list comprehension

\n

Do not use any other technique if you can use list comprehension. For example, here is a code to list all the numbers between 1 and 1000 that is the multiplier of 3:

\n
L = []\nfor i in range (1, 1000):\n    if i%3 == 0:\n        L.append (i)
\n

Using list comprehension, it would be:

\n
L = [i for i in range (1, 1000) if i%3 == 0]
\n

List comprehension works faster than using the append method.

\n

Use multiple assignments

\n

Do not assaign variables like this:

\n
a = 2\nb = 3\nc = 5\nd = 7
\n

Instead, assign variables like this:

\n
a, b, c, d = 2, 3, 5, 7
\n

Do not use global variables

\n

Python has global keyword to declare global variables. But global variables take higher time during operation than a local variable. So, do not use global variables if it is not necessary.

\n

Use library function

\n

Do not write your function (manually) if it is already in the library. Library functions are highly efficient, and you will probably won't be able to code with that efficiency.

\n

Concatenate strings with join

\n

In python, you can concatenate strings with + operation.

\n
concatenatedString = "Programming " + "is " + "fun."
\n

It can also be done with join() method.

\n
concatenatedString = " ".join (["Programming", "is", "fun."])
\n

join() concatenates strings faster than + operation because + operators create a new string and then copies the old content at each step. But join() doesn't work that way.

\n

Use generators

\n

If you have a large amount of data in your list and you need to use one data at a time and for once then use generators. It will save you time.

\n

It may seem efficient, but it's not

\n

See the below code:

\n
L = []\nfor element in set(L):\n    ...
\n

The above code may seem efficient because it used set to delete duplicate data. But the reality is that the code is not efficient. Do not forget that converting a list into set takes time. So this code will work better than the previous:

\n
for element in L:\n    ...
\n

Do not use dot operation

\n

Try to avoid dot operation. See the below programme.

\n
import math\nval = math.sqrt(60)
\n

Instead of the above style write code like this:

\n
from math import sqrt\nval = sqrt(60)
\n

Because when you call a function using . (dot) it first calls __getattribute()__ or __getattr()__ which then use dictionary operation which costs time. So, try using from module import function.

\n

Use 1 for infinity loops

\n

Use while 1 instead of while True. It will reduce some runtime.

\n

Try a different approach

\n

Try new ways to write your code efficiently. See the below code.

\n
if a_condition:\n    if another_condition:\n        do_something\nelse:\n    raise exception
\n

Instead of the above code you can write:

\n
if (not a_condition) or (not another_condition):\n    raise exception\ndo_something
\n

Use speed up applications

\n

For python's slow speed, some projects have been taken to decrease runtime. Pypy and Numba two of them. In most of the programming contests, you will see pypy if it allows python. These applications will reduce the runtime of your programme.

\n

Use special libraries to process large datasets

\n

C/C++ is faster than python. So, many packages and modules have been written in C/C++ that you can use in your python programme. Numpy, Scipy and Pandas are three of them and are popular for processing large datasets.

\n

Use the latest release of python

\n

Python is updated and upgraded regularly, and every release is faster and more optimized. So always use the latest version of python.

\n

These were some of the tips to decrease the runtime of python code. There are a few more techniques that you can use. Use a search engine to find those and write efficient code!

\n","frontmatter":{"date":"October 15, 2020","updated_date":null,"title":"Speed Up Python Code","tags":["Python","Performance"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/65558b9da57861b919205b297c81828b/58556/speed-up-python-code-1.webp","srcSet":"/static/65558b9da57861b919205b297c81828b/61e93/speed-up-python-code-1.webp 200w,\n/static/65558b9da57861b919205b297c81828b/1f5c5/speed-up-python-code-1.webp 400w,\n/static/65558b9da57861b919205b297c81828b/58556/speed-up-python-code-1.webp 800w,\n/static/65558b9da57861b919205b297c81828b/99238/speed-up-python-code-1.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Md. Tahmid Hossain","github":"tahmid02016","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/what-is-graphql/"},"html":"

GraphQL's popularity has skyrocketed since its release in 2015. It is the modern way of developing and querying APIs. GraphQL is an application programming interface (API) query language and server-side runtime that prioritises giving customers precisely the data they request.

\n

GraphQL is designed to make fast, scalable, and developer-friendly APIs. GraphQL allows developers to build requests that pull data from multiple data sources in a single API call as an alternative to REST.

\n

Foundation of GraphQL

\n

It was developed internally by Facebook in 2012 before being publicly released in 2015. \"On 7 November 2018, the GraphQL project was moved from Facebook to the newly-established GraphQL Foundation, hosted by the non-profit Linux Foundation.\"

\n

What is GraphQL?

\n

GraphQL is an application-level query language that helps data fetching and serving between client and server runtime by providing a standard protocol for queries. Its strength lies in the fact that it offers a modern, simpler, and efficient way to query and develop APIs. The real deal is its flexible data fetching -- the application only loads relevant data from the server. Also, GraphQL is hierarchical in nature; it structures relationships in a simple hierarchical manner to avoid complex queries while fetching data.

\n

Why to use GraphQL?

\n

GraphQL offers much power and flexibility over Traditional APIs. One of the few things GraphQL was designed, was to solve Data Fetching/Loading problems.

\n

Data fetching is one of the most critical factors responsible for the performance of the application. Most of the time, the data provided by the API isn't required to run the application. This problem is termed as \"Over fetching\", which can be a more significant issue in mobile devices. Since devices with slower network connection are bound to take more load time, it creates a negative impact on end-users.

\n

In the current scenario, traditional REST APIs offer no clean way to solve this problem; GraphQL comes to the rescue. It allows clients to define the structure of the data required, and the same structure of the data is returned from the server. Therefore preventing fetching loads and loads of data, ultimately increasing performance.

\n

API endpoints generally fetch specific data, hence to load a certain data-rich application, there have to be multiple requests to the server. But, applications should fetch relevant data in one round trip to avoid degrading performance. The flexibility and richness of the GraphQL, allows us to define all the data to fetch in a single request, avoiding multiple Round trips

\n

\"Wrapping\nWrapping REST API in graphQL - Source - Joey Ng'ethe | TwigaTech

\n

Fundamentals of GraphQL

\n\n\n\n\n\n\n\n\n\n\n\n
Server ->GraphQL Server ->Graphql Client ->Client
\n
\n

Schema - GraphQL follows a type system to define the schema of an API. The syntax for writing schemas is called Schema Definition Language (SDL).

\n
# A simple example to define schema\ntype Person {\n  name: String!\n  age: Int!\n}
\n

Query - The data or information that a client needs from a server can be fetched in a request using queries.

\n
# This query fetches all specifically names of all users\n{\n  users {\n    name\n  }\n}\n# This query fetches all names of all friends of user "Anup".\n{\n  user(name: "Anup") {\n    name\n    friend {\n      name\n    }\n  }\n}
\n

Mutation - Mutations are the way to modify data to the server; these include creating/updating/deleting data. They have similar syntax as queries, with special keywords ahead of them.

\n
# This mutation adds a user with name "Anup" and age 20.\nmutation {\n  addUser( name : "Anup", age: 20) {\n    name\n    age\n  }\n}
\n

Despite its powers, you might not need graphQL in your applications -

\n\n

Conclusion

\n

GraphQL is a step forward in the world of applications by providing a significant boost in performance. Another plus point of GraphQL is that it is not meant to replace any existing solution but enhance and co-exist with REST APIs. Simply put, the future of GraphQL looks bright.

\n","frontmatter":{"date":"October 01, 2020","updated_date":null,"title":"What is GraphQL? - A Basic Guide","tags":["Engineering","API","GraphQL","Performance"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/4674ea0950b63a1ff2d08638af559bc0/58556/graph.webp","srcSet":"/static/4674ea0950b63a1ff2d08638af559bc0/61e93/graph.webp 200w,\n/static/4674ea0950b63a1ff2d08638af559bc0/1f5c5/graph.webp 400w,\n/static/4674ea0950b63a1ff2d08638af559bc0/58556/graph.webp 800w,\n/static/4674ea0950b63a1ff2d08638af559bc0/210c1/graph.webp 900w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Anup Aglawe","github":"anup-a","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/a-journey-from-node-to-golang/"},"html":"

Migrating your existing code to a new programming language is a very tedious task. We need to have a proper set of requirements and some obvious benchmarking between the new and existing technology.

\n

So here our journey started to transform (not convert) our existing code to a new language. You might be thinking why I have used the word transformation instead of conversion, so -

\n

Conversion: Conversion is just about writing your existing code in different languages as it is.

\n

Transformation: Transformation is about leveraging all possible benefits of a new language and convert accordingly.

\n

Why we decided to change?

\n

The idea of migrating code to a new programming language started with a simple requirement: we wanted to take our cloud solution to on-premise as well. Till now, our services were written in NodeJS for a cloud solution and it was doing pretty well. The performance was also good but there is nothing that cannot be improved upon. So, along with performance improvement, we started to find out that can we make a GUI or CLI using existing NodeJS code that can take our solution on-premise?

\n

Answer for that was practically YES. but, technically NO. If we’re writing apps with a GUI, Node can’t do it on its own. We had to use some other projects which provide GUI creation capabilities (eg: ElectronJS, NW.js, etc). Making CLI seemed doable but there were also problems like the inablility to have single file distribution for our code. And the ability to download a single file and execute commands - without an installer, or even a setup process - does wonders for a user. This also makes the product easily backward-compatible.

\n

Also, another factor came in that it was better to switch to a technology that works closely with gRPC.

\n

So, we drew out a few goals for our new solution

\n\n

After research with our requirement, we were able to figure out that we can achieve these with GoLang, developed by Google.\nOn the basis of our research, we also did some benchmarking on different node js frameworks and GoLang.

\n

Benchmarking sever we’ve used with below configurations

\n

\"server\"

\n

The benchmarking result was pretty much similor to what we are thinking. Here are the benchmarking results -

\n

100000 Requests 5000 Concurrency

\n

\"sheet1\"

\n

100000 Requests 7500 Concurrency

\n

\"sheet2\"

\n

There was a big difference. For better clarity let’s see the below graphs.

\n

Total Time taken for Test(s)

\n

In the below chart, we can clearly see that Golang won the competition and Hapi has taken the maximum time to finish the test.

\n

\"total-time-taken-for-test\"

\n

Request per second (s) and Transfer Rate kb/s

\n

In the below chart, we can see that Golang served maximum requests per second.

\n

\"request-per-second-and-transfer-rate-kb-s\"

\n

Request per second (s) and Time per request (ms)

\n

The below chart is showing that the Number of requests is very high compared to other node js frameworks.

\n

\"request-per-second-and-time-per-request\"

\n

Total Data Transferred

\n

\"chart\"

\n

All the data clearly shows the direction so we decided to move to GoLang.

\n","frontmatter":{"date":"August 11, 2020","updated_date":null,"title":"A journey from Node to GoLang","tags":["NodeJs","Golang","Performance"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/7495b241d8dd853cf8580344cc9332f2/ad85c/node-go.webp","srcSet":"/static/7495b241d8dd853cf8580344cc9332f2/61e93/node-go.webp 200w,\n/static/7495b241d8dd853cf8580344cc9332f2/1f5c5/node-go.webp 400w,\n/static/7495b241d8dd853cf8580344cc9332f2/ad85c/node-go.webp 600w","sizes":"(max-width: 600px) 100vw, 600px"}}},"author":{"id":"Narendra Pareek","github":"pareek-narendra","avatar":null}}}}]}},"pageContext":{"tag":"Performance"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}