Deep Dive into Jira Issue Archival

In this article, I'd like to discuss a robust solution in the dynamic world of project management. Jira offers powerful features to track and manage issues seamlessly. However, we realized that our Jira Cloud platform was missing one essential feature – the ability to archive and unarchive issues, a tool many of our valued customers deemed significantly necessary.

Recognizing this need for an issue archival feature in Jira cloud marked the beginning of our journey. We embarked on this path to not only develop this feature but ensure that it enhances user experience significantly. This path to success was filled with challenges and required innovative solutions. But, in the end, we succeeded in producing a feature that enriches Jira Cloud's functionality and facilitates a smoother transition for our users, especially those migrating from server to cloud. So, let's dive in and explore this exciting journey.

Issue Archival in Jiras Issue Life Cycle

Jira is acknowledged as a leading task management tool in various industries. A key aspect of its functionality is the management of issues through a specific life cycle, which includes stages such as creation, viewing, updating, and transitioning of issues.

• Creation: This initial stage involves creating an issue with specific details required and only authorized personnel being able to create them.
• View: This stage allows users to view the created issues.
• Update: Here, modifications or updates to the issues are made.
• Transition: This phase refers to moving an issue from one status to another, for example, transitioning from "In Progress" to "Done" or "Resolved.”

However, as companies create thousands of issues daily that grow larger over time, a crucial question arises - what happens to resolved issues? Will they be useful?

Many companies want to retain these resolved issues for auditing purposes, compliance with company policies, and future reference. However, they don't want these issues displayed everywhere, such as in Completed Epics in Timeline, Boards section, and List of Issues section. Showing these resolved issues can lead to visual clutter that can impede user productivity when dealing with a large set of irrelevant issues.

This is where the concept of Issue Archival comes into play, especially when resolving states transitioned like "Done" or "Resolved". Issue Archival is designed to retain records while preventing them from cluttering the active workspace.

Furthermore, this feature has been highly requested by customers migrating to the cloud because there aren't many archival features available. Hence, the Issue Archival feature was implemented in the cloud -to reduce visual clutter and facilitate migrations.

The Architecture of Issue Archival

The architecture of issue archival in Jira is built to ensure smooth user experience. When an issue is archived, it is removed from all user experiences in real-time, including the Timeline, Boards, and Global Issue Search. This removal helps maintain a clean and clutter-free interface. While it sounds simple, this process involves complex backend operations designed to handle the removal efficiently without affecting the overall system performance.

Furthermore, our Archive/Unarchive APIs are highly efficient and can handle up to 1000 issues in one go, serving these requests in seconds. This capability significantly simplifies the archiving process, especially for larger projects.

One of the most significant features is the Submitting Task to Archive Issues. This feature utilizes Jira's own Jira Query Language (JQL), a flexible and expressive query language that allows users to specify which issues they want to archive. For instance, if users want to archive the issues in specific projects, between particular date ranges, or issues archived by a particular person, they can phrase their JQL accordingly, and our system will take care of the rest and complete the task in minutes. This capability significantly simplifies the archiving process, making it more efficient and user-friendly.

The Process of Archiving and Unarchiving Issues

Archiving issues involves removing them from all user experiences and revoking all edit permissions. Once an issue is archived, it can only be accessed via a direct link and is available in read-only mode. This ensures the integrity of the archived data while allowing compliance and auditing procedures to be carried out smoothly.

On the other hand, unarchiving an issue restores its active status. All permissions are reinstated, and the issue is reintroduced to all user experiences and searches. This process is designed to be smooth and instant, providing a smooth user experience

We have introduced a banner on each archived issue to help users differentiate between active and archived issues. This banner clearly states, "The issue is archived; you can't perform any operation." This way, users can quickly identify archived issues and understand their limitations.

Impact of Archival on Migrations

Migration of archived issues from server to cloud is critical in ensuring data consistency. We handle the migration process carefully to prevent any data inconsistencies. If we encounter missing data during migration, we perform data manipulation operations to fill in the gaps and maintain consistency. This careful handling ensures that once the migration is completed, the archived issues behave in the cloud environment precisely as they would in the server environment.

Challenges and Solutions

Throughout the development of this feature, we faced numerous challenges.

Latency of Sync APIs

One of the challenges we faced was efficiently managing bulk archiving and unarchiving of issues through APIs, which could handle up to 1000 issues at a time. Due to its synchronous nature, this is a significant task that requires careful consideration of Latency.

To tackle this, we divided the 1000 issues into 10 batches and processed these in transactions. This method required comprehensive performance testing to ensure we could achieve a latency range of 100ms to 10 seconds when archiving issues ranging from 10 to 1000 in number.

Latency is a critical element when handling large data sets in synchronous to ensure smooth operation.

?

Decisions of Async API

One of the main challenges we faced was developing a feature that would enable users to archive issues based on their personal preferences. The conventional method of passing a list of issue keys via the Synchronous API proved inadequate for this task.

Consider a scenario where a customer wants to archive all issues within a specific date range attributed to a particular user across multiple projects. Performing this task via the traditional API would be extremely challenging. To address this, we came up with the idea of leveraging the existing JQL language.

Most Jira users are already familiar with JQL, and it offers them the flexibility to query any type of issues using a wide range of available options. Users can construct a JQL query and then use the Asynchronous Archive API to pass the query through a request. This action initiates a job.

In the backend, the system validates the query, fetches all the issues based on the query parameters, and archives them in transactional batches. This approach empowers users to archive a massive number of issues based on any JQL expression

Sample Request

{ "jql":"project in ('project1', 'project2') and assignee = userAccountId and status = Abandoned and created < 2022-01-01" }        

Real-Time Updates

Another challenge was maintaining the real-time removal of archived issues from all user experiences. This process involved different project types, including team-managed and company-managed projects, each with its own way of consuming events and updating their cache. Balancing these different types while ensuring consistency was indeed a challenging task.

Our solution was to develop a robust backend operation that efficiently handles the removal process. We also implemented a performance benchmark to ensure the system's performance remains optimal even with thousands of archived issues.

Issue History

Another challenge was tracking the history of events. To maintain consistency and facilitate future auditing, we needed to implement a system that accurately records who archived and unarchived each issue along with a timestamp. This tracking is done in the cloud, ensuring that all issue histories are accurately maintained.

During the migration from server to cloud, we faced the challenge of transferring all issue history information. This included information such as when the issue was archived (at the same time, it was archived on the server) and who (the same person who archived it on the server). Ensuring this data was accurately transferred and maintained was a complex task but was critical for making the system more consistent and resilient. To overcome these challenges, we developed robust backend operations that efficiently handle the removal process, track the history of events, and manage data transfer during migration.

Page Rendering

Post-archiving of issues, we noticed a significant increase in page rendering speed at the user interface. The removal of visual clutter not only improved system performance but also made the user experience look cleaner and neater.

Handling Missing Data During Migration

Another challenge was handling the migration of archived issues from server to cloud. Due to the differences in the two environments, ensuring data consistency was a complex task. Our solution was to create a thorough mapping of all the required data for issue archival. This mapping helped us identify and handle missing data, thus reducing inconsistencies and ensuring a smooth migration process.

The development of the Issue Archival feature in Jira was indeed a challenging task. However, we found an opportunity to improve and innovate with every challenge we faced.

Whats Coming Up

The development of the Issue Archival feature in Jira presented numerous challenges and learning opportunities. Despite the complexities, we successfully created a feature that enhances user experience and system performance. We aim to inspire and assist others facing similar challenges through sharing our experiences.

With the introduction of the Issue Archival feature in the cloud, users no longer need to concern themselves with deleting issues. They now have the option to archive issues they don't want to see, with the assurance that they can be accessed later.

As we continue to refine and enhance this feature, we are delighted to announce that we are currently working on another new feature called Trashed.

Trashed:

• Trashed issues can be easily restored/recovered within X days, after which they will be moved to DELETED state.
• Users think they don’t need the issue anymore and want it to be removed from their project etc. So when users try to remove an issue, it should first move it to TRASHED state. This would accommodate scenarios where accidentally deleted data can be recovered.
• There should also be an option to delete trashed issues and move them to DELETED state manually. (also known as emptying the trash or recycling bin)

This marks just the beginning as we roll out version 1.0 of Issue Archival; anticipate more exciting UI features designed for enhanced archiving and accessibility of issues. Continue using Jira for a seamless and efficient task management experience.

Stay tuned for further updates and features!