How to handle rate limiting with Python JIRA API?

Other Questions Jira
1

I’m developing a script to automate some tasks on our company’s JIRA instance. It’s a real time-saver compared to doing everything manually through the web interface.

The problem is, our JIRA has pretty tight rate limits. Right now, I have to add a 3-minute pause after every 3 requests to avoid hitting the limit. It’s not ideal.

I know the rate limit info is in the response headers, but I can’t figure out how to access them using the Python JIRA library. I’ve looked through the docs, but no luck so far.

Does anyone know if it’s possible to get these headers when using the Python JIRA client? Or maybe there’s a built-in way to handle rate limiting that I’m missing?

Here’s a basic example of what I’m doing now:

from jira import JIRA
import time

jira = JIRA(server='https://example.com', basic_auth=('user', 'pass'))

for i in range(10):
    issue = jira.create_issue(project='TEST', summary='Test issue')
    print(f'Created issue: {issue.key}')
    
    if (i + 1) % 3 == 0:
        print('Waiting 3 minutes...')
        time.sleep(180)

Any tips would be super helpful!

2

hey ryan, i’ve dealt with similar issues. one trick is to use the requests library directly instead of the jira client. you can access headers that way. something like:

import requests
response = requests.get('your_jira_url', auth=(user, pass))
rate_limit_info = response.headers['X-RateLimit-Remaining']

hope that helps! lemme know if u need more info

3

I’ve encountered this exact problem in my work automating JIRA tasks. While the requests library approach works, I found a more elegant solution using the ‘jira-python’ library’s built-in rate limiting feature. You can set it up like this:

from jira import JIRA
from jira.client import translate_resource_args

jira = JIRA(server='https://example.com', basic_auth=('user', 'pass'))
jira._options['agile_rest_path'] = 'agile'
jira._options['agile_rest_api_version'] = '1.0'
jira._options['max_retries'] = 3
jira._options['delay_between_retries'] = 10

This configures the client to automatically handle rate limiting by retrying requests with exponential backoff. It’s been a game-changer for me, eliminating the need for manual sleep calls and making my scripts much more efficient. Just remember to adjust the ‘max_retries’ and ‘delay_between_retries’ based on your specific JIRA instance’s limits.

4

I’ve tackled this issue in my own JIRA automation projects. One effective approach I’ve found is to implement a custom rate limiter class. Here’s a simplified example:

import time
from jira import JIRA

class RateLimiter:
    def __init__(self, max_calls, period):
        self.max_calls = max_calls
        self.period = period
        self.calls = []

    def __call__(self, func):
        def wrapper(*args, **kwargs):
            now = time.time()
            self.calls = [c for c in self.calls if now - c < self.period]
            if len(self.calls) >= self.max_calls:
                time.sleep(self.period - (now - self.calls[0]))
            self.calls.append(now)
            return func(*args, **kwargs)
        return wrapper

jira = JIRA(server='https://example.com', basic_auth=('user', 'pass'))
rate_limit = RateLimiter(max_calls=3, period=180)

@rate_limit
def create_jira_issue(project, summary):
    return jira.create_issue(project=project, summary=summary)

for i in range(10):
    issue = create_jira_issue('TEST', f'Test issue {i}')
    print(f'Created issue: {issue.key}')

This approach allows for more fine-grained control over rate limiting without relying on hard-coded sleep times. It’s been quite effective in my experience.