Service Project Integration

Part of the Administration reference. API Restrictions | Admin Tools | Audit Logs | Service Projects

Overview

Service Project Integration lets the application create Jira issues in a project you choose when certain events occur - script errors and configuration drift - and track which issues scripts have touched. The project can be any Jira project, including a Jira Service Management project.

This feature has two parts, each on its own tab of Admin Panel -> Admin:

  • Service Project tab - the target project, default fields for created issues, and the Error Notifications and Drift Notifications switches
  • Issue Tracking tab - buffered sync of script execution data to issue properties

Service project configuration

Configure the target project on the Service Project tab (section Service Project Configuration).

Project selection

Select the target Jira project where issues will be created. The list shows the projects you can browse.

The picker reads the project list from Jira page by page to the end (up to 40 pages of 50 projects). If Jira does not return every project (the limit is reached or a page fails midway), the picker shows: “This list is incomplete: Jira did not return every item, so some may be missing here. Narrow the search or reload.”

Issue type

Set the issue type for created issues. Available issue types depend on the selected project. If no issue type is selected, error notification issues are created as Bug and drift notification issues as Task (the form shows “Default: Task”).

Summary customization

Setting Description
Summary Prefix Text prepended to issue summaries (e.g., [Studio])
Summary Postfix Text appended to issue summaries

Summaries are cut to 255 characters.

Metadata

Setting Description
Labels Comma-separated labels applied to created issues
Component Default component assigned to created issues
Assignee Default assignee (searchable by name, minimum 2 characters)

Save / clear

  • Save - store the configuration
  • Clear - remove the configuration; error and drift notifications stop because no project is configured

All changes are recorded in the Settings audit log.


Error notifications

Turn on Enable error notifications to create a Jira issue when a script fails (see Error Monitoring):

  • A new error creates an issue with the error details, a link to the script, the trigger context and the first input data. The issue gets the label studio-auto-error in addition to the configured labels
  • Repeated occurrences of the same error add a comment to that issue at 5, 10, 50, 100, 500 and 1,000 occurrences
  • Trigger Types - create issues only for errors from the trigger types switched on in the list (each trigger type has a switch). All trigger types except manual runs are selected by default
  • Send Test Issue - creates a [TEST] issue to verify the configuration (error notifications must be enabled)

Drift notifications

Turn on Enable drift notifications to create a Jira issue when a drift check finds changes against a compliance baseline (see Compliance & Drift Monitoring):

  • The first detection creates an issue with a summary of the changes and the full report attached as a CSV file. The issue gets the label studio-drift-detected in addition to the configured labels
  • Later detections for the same baseline add a comment to the existing issue instead of creating a new one; unchanged drift adds nothing
  • Send Test Drift Issue - creates a [TEST] issue to verify the configuration (drift notifications must be enabled)

Issue creation

Created issues use:

  • Summary composed from prefix + notification summary + postfix
  • Description with the notification details
  • Configured labels (plus the notification label), component and assignee
  • Issue type from the configuration, or the default described above

At most 100 issues per day (UTC) are created for error and drift notifications together; after that, new notifications are skipped until the next day. Comments on existing issues are not limited.

Issue creation is non-blocking - if creation fails, the error is logged but does not affect the triggering operation.


Issue tracking

Issue tracking records which Jira issues were affected by script executions. This data is buffered and synced periodically to Jira issue properties.

Tracked operations

For runs of saved scripts, the following is recorded automatically:

Operation What triggers it
run The script ran in the context of an issue
create POST /rest/api/{2,3}/issue
update PUT /rest/api/{2,3}/issue/{key} or any PUT under it, POST to issue sub-resources (comment, worklog, watchers, …)
transition POST /rest/api/{2,3}/issue/{key}/transitions
delete DELETE /rest/api/{2,3}/issue/{key}

Read operations (GET) are not tracked.

How it works

  1. When a script runs on an issue or modifies a Jira issue (create, update, transition, etc.), an entry is added to the tracking buffer
  2. Once a day, at the configured sync hour, a sync process reads pending entries and writes them as Jira issue properties via the bulk API, in batches of 100 issues
  3. Issue properties include a history of which scripts affected the issue, with timestamps and results

Sync settings

Setting Description
Enable issue execution tracking Toggle issue tracking on/off. On by default
Daily sync hour Hour when buffered data is synced to issue properties, picked in a drop-down from 00:00 to 23:00 (site timezone). Default: 03:00
Sync now Run the sync immediately

The tab also shows how many pending entries for how many issues are waiting to be synced.

The tab description gives a sample JQL query, issue.property[studio-executions].runCount > 0, in code font; more queries are under JQL queries.

Sync process

The sync runs at the configured hour and processes entries in batches of 100 issues:

  1. Pending entries are grouped by issue
  2. Existing issue properties are fetched via search API
  3. New data is merged with existing history
  4. Properties are written via Jira bulk API
  5. Synced entries are removed from the buffer 30 days after they were recorded

Buffer states

Entries in the tracking buffer move through three states:

State Description
Pending Waiting for sync
In-flight Currently being synced via Jira bulk API
Synced Successfully written to Jira issue properties

Synced entries are removed from the buffer 30 days after they were recorded. In-flight entries that stall for 24 hours are automatically reset to pending.

Issue property format

Each tracked issue gets a property studio-executions with the following structure:

Field Type Description
lastRunAt string ISO 8601 timestamp of the last script execution
lastScriptId string ID of the last script that affected this issue
runCount number Total number of recorded script executions for this issue
hasErrors number 1 if any execution ever failed, 0 otherwise (sticky - never resets to 0)
scriptIds string Space-separated list of all script IDs that affected this issue
history array Recent execution entries (max 400)

Each history entry:

Field Type Description
ts string ISO 8601 timestamp
sid string Script ID
vid string/null Script version ID
ok number 1 for success, 0 for failure

Example:

{
  "lastRunAt": "2026-01-15T10:30:00+00:00",
  "lastScriptId": "abc-123",
  "runCount": 5,
  "hasErrors": 0,
  "scriptIds": "abc-123 def-456",
  "history": [
    { "ts": "2026-01-15T10:30:00+00:00", "sid": "abc-123", "vid": null, "ok": 1 }
  ]
}

JQL queries

Issue properties are indexed and searchable via JQL:

issue.property[studio-executions].runCount > 0
Query Description
issue.property[studio-executions].runCount > 0 Issues affected by any script
issue.property[studio-executions].hasErrors = 1 Issues where a script execution failed
issue.property[studio-executions].lastScriptId = "script-id" Issues last affected by a specific script
issue.property[studio-executions].scriptIds ~ "script-id" Issues ever affected by a specific script
issue.property[studio-executions].lastRunAt > "2026-01-01" Issues affected after a specific date
issue.property[studio-executions].runCount > 10 Issues affected more than 10 times

Limits

Limit Value
Max property size 32 KB (Jira limit)
Max history entries 400 per issue
Buffer retention 30 days
Sync batch size 100 issues per batch

Notes

  • Scripted field and UIM executions are not tracked
  • Sandbox mode executions are not tracked
  • Deleting a script does not remove tracking data from issues - existing entries remain in issue properties
  • Tracking is fire-and-forget - it does not affect script execution performance
  • Changes to the tracking settings are recorded in the Settings audit log

Troubleshooting

Issue Solution
Pending count not decreasing Check that the sync hour matches expectations (uses site timezone). Use Sync now for a manual sync
Entries stuck in-flight In-flight entries are automatically reset to pending after 24 hours. The next sync will retry them
No data on issues Verify tracking is enabled. Only runs on an issue and write operations (create/update/transition/delete) of saved scripts are tracked, not reads; scripted field, UIM and sandbox runs are not tracked

Next steps


JiBrok Studio for Jira Cloud JiBrok Studio for Jira Cloud
Release notes
Core Features
Triggers
Extensions
Data Storage
Scripting Overview
JavaScript Engine
Python Engine
Groovy Engine
Scripting API
Administration
Guides