Table of contents

Depending on the volume of data returned by the datasource and the execution time of the requests, you may experience slowness when editing or displaying issues. 
Performance issues can have many causes, but in certain cases changing your configuration can help.

In this section, you'll find hints on how to improve performances.

Configure a display view query

Problem

Imagine that you have a Elements Connect field based on the following SQL request:

SELECT user_id, username, last_connection_date 
FROM Users

When the field is edited, Elements Connect fetches the whole set of users, there are thousands of lines.

When the field is displayed, Elements Connect executes the same request again and tries to match the user_id column with the value(s) stored in your field.
This takes the same amount of time to display the field. And this happens any time someone displays an issue.

Solution

When the field is displayed, it is not needed to get the entire set of users to only display one record.

The solution is to configure a specific display query that only retrieves the value selected on display using the $currentCustomfieldValue variable (see Velocity).

Display query

SELECT username, last_connection_date 
FROM Users 
WHERE user_id = $currentCustomfieldValue

This request will return instantly with one result (especially if you have an index on the user_id) and will be faster than the edit query.

Use the autocomplete editor and $userInput

Problem

Generally, the autocomplete is used when there is in a large amount of options to display. The autocomplete allows the user to input text to filter the results.
This is convenient on the browser side, but this means that you have a large amount of data in your datasource too. Your field can take time to load.

Imagine that you have a Elements Connect field based on the following SQL request:

SELECT user_id, username
FROM Users

This query returned 100,000s of results.

Instead of loading the whole issues list, we would like to limit the issues returned to what the user typed.

We need to change a few things in your field configuration

Solution

The $userInput  Velocity variable is available for use in your query. It contains what the user typed in the autocomplete.
When this variable is used in the query, the autocomplete will execute the query every time the user types something different.

If you do not use $userInput  in your query, the field will only fetch the results once and filter them locally.

Change your edit query like this:

SELECT user_id, username
FROM Users
WHERE username like '%$userInput%'
LIMIT 15

That way, only the first 15 users matching the user input will be retrieved from the datasource.

Troubleshooting

• Datasource results do not show up in an autocomplete field when using $userInput

Don't execute useless queries with $query.abort()

Problem

Imagine that have two fields Company and Contact. The contact depends on the company but does not make sense if company is not set.

Company configuration (field id: 10001)

SELECT id, name
FROM Companies

Contact configuration

SELECT id, name
FROM Contact
WHERE company_id = $issue.customfield_10001

The Contact field request is executed every time, even if the company is not set. This will certainly return an empty list and nothing is displayed in the field.

From the end user, this is ok, but this would be far better if we could avoid making a useless request to the server.

This is where $query.abort()  enters the scene.

Solution

If we change the last query to this:

#if(!$issue.customfield_10001 || $issue.customfield_10001.length() == 0)
    $query.abort()
#end
SELECT id, name
FROM Contact
WHERE company_id = $issue.customfield_10001

When the Company (customfield_10001) is unknown or empty, the request evaluation encounters the $query.abort() statement.

In this case, the request process is stopped and an empty result is returned.

This works exactly as if the request returned no result, but the useless request to the datasource is avoided.

This is particularly helpful when you have a lot of depending fields.

Enable Elements Connect cache

Enabling the cache can help with performances when you use the same requests a lot during a short period of time.

How does it work ?

The cache stores the result of a request to a datasource for a certain amount of time. If during this time the exact same request is made again, then the result previously stored is returned instead of calling the datasource again.

You can enable the cache in every field advanced configuration.

 The cache is stored in memory.

Do I need to enable it ?

Enabling the cache has advantages as it lowers the number of requests made to a datasource and allows a faster resolution of a field content.

But this also comes with a cost : The cache consumes memory and the results from the cache might not be up to date compared to the datasource.

What value for the cache duration ?

The cache duration tells how long a request result is kept in memory. Past this time, the memory is freed and if the same request happens again, then the datasource is called (and the cache populated again)

The minimum cache duration is 1 second.

This is hard to tell exactly what value you need for your configuration, but here are three different examples that can help you guess:

You have many fields with the same query on every issues

Your Jira is loaded and you have many users watching different issues at the same time

Your datasource is updated at night only

Enable gzip compression for URL datasources

Problem

Sometimes when making HTTP calls, the server response size may considerably degrade response times due to large volume of data. Elements Connect fields and Jira pages may seem slow and unresponsive.

Solution

To improve performances, some servers can handle gzip compression before sending content which may drastically reduce response times. To tell the server to compress data with gzip, HTTP protocol proposes a standard way which may be easilly specified in an Elements Connect datasource configuration: add an Accept-Encoding header with gzip value.