Long Running Jobs

Long Running Jobs in Vaktum

Vaktum provides support for long-running jobs that enable continuous API testing, monitoring, and validation over extended periods.

What are Long Running Jobs?

Long running jobs are automated processes that:

• Run continuously or on a recurring schedule
• Monitor APIs for changes, regressions, or performance issues
• Generate alerts when issues are detected
• Collect historical data for trend analysis

Types of Long Running Jobs

Scheduled Test Runs

Regular execution of test suites against specified environments:

• Hourly, daily, weekly, or custom schedules
• Run comprehensive test suites to validate API functionality
• Compare results against previous runs to detect regressions
• Generate trend reports showing API stability over time

API Monitors

Continuous monitoring of API endpoints for availability and performance:

• Ping critical endpoints at regular intervals (e.g., every minute)
• Measure response times and error rates
• Alert on downtime or performance degradation
• Create health dashboards for API status visualization

Schema Change Detection

Automated detection of changes to your API schema:

• Regular comparison of current API schema against baseline
• Detection of potentially breaking changes
• Notification when new endpoints or fields are added
• Documentation updates when schema changes are detected

Setting Up Long Running Jobs

Via Vaktum.com

1. Navigate to the Jobs section of Vaktum.com
2. Click "Create Job"
3. Configure your job:
   • Type: Select the job type (test run, monitor, etc.)
   • Schedule: Define when and how often the job should run
   • Resources: Select the API, test suite, or environment
   • Notifications: Configure alerts for specific events
   • Retention: Set how long results should be kept
4. Click "Save" to activate the job

Via Vaktum API

Create jobs programmatically using the Vaktum API:

curl -X POST "https://api.vaktum.com/v1/jobs" \
  -H "X-API-KEY: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Hourly API Health Check",
    "type": "monitor",
    "schedule": "0 * * * *",
    "resources": {
      "apiId": "your-api-id",
      "environmentId": "your-environment-id",
      "endpoints": ["/health", "/status"]
    },
    "notifications": {
      "onFailure": true,
      "channels": ["email", "slack"]
    }
  }'

Job Management

The Jobs dashboard provides tools to manage your long-running jobs:

• Status Monitoring: View the current status of all jobs
• History Viewing: Examine previous job runs and their results
• Manual Triggering: Run jobs on-demand when needed
• Pausing/Resuming: Temporarily disable jobs during maintenance
• Configuration Updates: Modify job settings as requirements change

Resource Considerations

Long-running jobs consume resources that may impact your plan limits:

• API Calls: Each job execution counts toward your API call quota
• Storage: Job results are stored for the configured retention period
• Concurrency: Multiple simultaneous jobs may require higher tier plans

Best Practices for Long Running Jobs

• Start Small: Begin with critical endpoints before expanding coverage
• Optimize Frequency: Balance monitoring frequency with resource usage
• Set Meaningful Alerts: Configure notifications for actionable issues
• Use Dedicated Environments: Create environments specifically for monitoring
• Review Regularly: Periodically review job configurations and results

Example Use Cases

API SLA Monitoring

Monitor your API's compliance with service level agreements:

1. Create a job that tests response times for critical endpoints
2. Set thresholds based on your SLA commitments
3. Generate weekly reports showing SLA compliance
4. Alert stakeholders when SLA violations occur

Regression Detection

Automatically detect when new code breaks existing functionality:

1. Establish baseline test results for your stable API
2. Run the same tests automatically after each deployment
3. Compare results to identify new failures
4. Block problematic deployments from reaching production

Documentation Freshness

Ensure your API documentation stays current:

1. Schedule regular jobs to compare API implementation with documentation
2. Detect undocumented endpoints or parameters
3. Generate notifications when documentation needs updating
4. Maintain an audit trail of API changes over time