rss feed Hangfire Pro

Maintenance release that brings better transaction behavior in case of operation failures and fixes problems with distributed locks when channelPrefix option is used.

This release enhances the resiliency of subscription-related connections when listening empty queues or awaiting the release of distributed locks.

This maintenance release includes automatic cleanup logic for empty queues or queues full of expired jobs to prevent them from getting stuck in the Dashboard UI. Additionally, it addresses a memory leak issue related to transaction-level locks introduced in Hangfire 1.8.0.

Maintenance release with better Redis Cluster connectivity in corner cases, source link support with embedded sources, signed NuGet packages and their assemblies with our code-signing certificate and more secure CI pipeline.

Maintenance release with hidden action buttons in a read-only dashboard change backported from version 3.0.3.

Maintenance release with hidden action buttons in a read-only dashboard and signed NuGet packages, all the assemblies and executable files with a company-owned code signing certificate.

Patch releases with important fixes for nested batches and enabled source link support with fully embedded sources to simplify the debugging experience.

Maintenance release that fixes a problem with displaying Scheduled Jobs page in the Dashboard UI for background jobs with an explicit queue specified.

Maintenance releases with fixed regressions from 3.0.0 and more consistent state transition logic when empty batches are used.

This release uses new features of Hangfire 1.8 to make batches even better. It supports new storage methods to have fewer storage roundtrips, allows explicit queues for batch continuations, adds new widgets to the Job Details page to simplify the navigation between jobs and those batches, and supports a stricter Content Security Policy for Dashboard UI.

Patch release that fixes a corner-case related to setting a null value to job parameters, adds static analysis back and a fixes a few other issues.

Accompanying the release of Hangfire 1.8.0, it supports all the new storage features, including first-class support for explicit queues for jobs, reduced number of network calls when creating or processing background jobs and Redis Server as a time authority for schedulers.

This version has a compatibility patch for highly popular Hangfire.Console extension so it can’t slow down the background processing when CLR’s Thread Pool is starved.

This patch version fixes possible “stuck batch” issue when state of a job inside a batch continuation is changed externally before that batch continuation is started. Such state transitions shouldn’t be used, because they violate encapsulation, but nevertheless while they aren’t prohibited by the code, we should handle such cases somehow.

This patch version contains improved logging for SSL/TLS authentication routine to understand what’s actually happened when something went wrong with the DEBUG log level enabled for the Hangfire.Pro.Redis namespace.

This release fixes ArgumentException when accessing the Dashboard UI with Redis metrics enabled if Redis Server instance has multiple additional modules installed.

This patch release fixes a regression appeared in 2.8 version related to the LUA-based transaction implementation, which didn’t take StackExchange.Redis’s ChannelPrefix option into account when enqueueing a background job id, causing the processing to hang when custom channel prefix is used.

This is a small maintenance release that just add missing overloads for the ContinueBatchWith method that allows to use background jobs based on asynchronous methods as continuations for batches. But this will unfortunately work only for .NET Core platform. Unfortunately support for .NET Framework will come only with version 3.0, because breaking changes required in this case.

This maintenance release fixes the order in which enqueued jobs are displayed on Queues and Enqueued Jobs pages in Dashboard UI or returned from Queues and EnqueuedJobs methods from the Monitoring API component. Now jobs that will be dequeued first are displayed first as expected. Also decreased maximum number of commands per LUA command execution to 200K, others are moved to a subsequent command (previous value was 1M).

This release fixes a regression appeared in the previous version 2.8.14 when multiple jobs storages are used – background jobs started to be processed one by one in this case.

This release fixes “too many results to unpack” regression appeared in 2.8.X when using batch continuations with a lot of background jobs.

Maintenance release that fixes fatal error in connection manager after long period of reconnects and “ConnectionMultiplexer is not a Sentinel connection” error when using Hangfire.Pro.Redis.SEv2 package and trying to reconnect to Sentinel nodes after a failure.

This release fixed another problem which appear with large number of servers and relates to huge amount of “Removing server…” log messages after ungraceful shutdown. Now method which is responsible for removing inactive servers uses a distributed lock to avoid concurrency and produce less Redis commands and logs.

This release reduces the network bandwidth consumption in environments with hundreds of servers and hundreds of queues. There were unnecessary calls to SMEMBERS servers command in the FetchedJobsWatcher component responsible for fault detection, leading to ServerCount*QueueCount number calls to it.

This maintenance release forces Hangfire.Pro.Redis to always use dedicated threads for reading Redis responses, even on Windows where IOCP threads were used by default. This will help to avoid slowdowns and timeout exceptions when all IOCP threads are busy or blocked by user code. This change is made because System.Net.Http.HttpClient package began to leak IOCP threads to user code, starting from one of the recent versions.

It is now possible to add batch continuations with new OnlyOnCompletedState and OnlyOnDeletedState options. The BatchContinuationOptions enum now allows to specify multiple values, so it is possible to mix different options to create a continuation that fire in multiple cases. For example continuations with OnlyOnSucceededState | OnlyOnCompletedState option specified will only be executed once antecedent batch is either succeeded or completed – but not deleted, e.g. canceled.

This maintenance release adds more logging only, but now almost every exception that occurs inside StackExchange.Redis package is logged with the DEBUG log level. So internal errors can be tracked now much faster than before.

This is a maintenance release that increases reliability after failovers when using older Redis version with asynchronous replication enabled.

This release fixes problems with missing performance counter instances in Performance Monitor due to changed instance naming rules in Microsoft.Owin.* packages of version 3.X and the absence of instance name sanitization.

General improvements for Hangfire.Pro.Redis with better error messages that contain actual problem (for example “No such host is known” instead of “SocketFailure on PING”), eliminated last bits of thread pool usage when using synchronous methods (so everything will be stable now when thread pool threads are busy) and other fixes.

This is an important maintenance release that fixes regressions appeared in version 2.8.0. Please consider upgrading especially if you are using batches with 25,000 background jobs and more.

The RedisStorageOptions.MaxStateHistoryLength option is added in this release to limit the number of state history entries and avoid storage leak when some background job is rescheduled again and again. By default, only 10 state history entries are now persisted, but this value can be configured with the new option.

This version fixes regression appeared in 2.8.0 which leads to occasional SemaphoreFullException exception when distribute lock can’t be obtained and timeout exception should be thrown instead. Also the RelyOnInternalReconnects experimental option was added to test less aggressive reconnection logic built into SE.Redis package.

This release fixes possibly hanging continuations for background jobs which belong to a canceled batch. Problem was caused by wrong execution order between BatchSupport and ContinuationsSupport filters, and the former now runs before the latter to give it a chance to recognize antecedent background job was deleted.

These are maintenance releases that fix blocking issues appeared in version 2.6.0 when using multiple RedisStorage instances in the same process with the same queue names, avoid sharing the same semaphore for different storages when using distributed locks, add RedisStorageOptions.UseLegacyTransactions option to avoid using LUA-based transactions and add experimental Hangfire.Pro.Redis.SEv2 package based on StackExchange.Redis 2.X.

This version contains the most important changes for request/response processing pipeline since version 2.1 in terms of performance. LUA scripting feature is now used to implement transactions with proper locking, and it is much more efficient than the previous implementation based on conditional transactions. Less round-trips, reduced impact caused by latency, optimized distributed locks and better fetching from multiple queues makes this release so important, especially when using the package in a cloud environment.

This version adds support for authenticating with username available in Redis 6 to use ACL support. Just add username= or user= option to your connection string, and you’ll be able to use the same Redis instance for multiple tenants with proper data isolation between them.

The new pre-release version brings significantly improved command pipeline with less stalls due to the absence of conditional transactions (now using LUA scripting instead of them), less round-trips to Redis, decreased latency when obtaining distributed locks and optimized fetching from multiple queues using a single command. These changes heavily increase the throughput especially when using Redis in a cloud environment or using complex features in Hangfire.

This is a maintenance release that fixes some connectivity problems that may occur in corner cases, such as cluster fail-over and connection timeouts.

This is yet another maintenance release that allows to turn off certificate revocation checks when using SSL/TLS.

Maintenance update for Hangfire.Pro.Redis package that comes with some fixes, including NullReferenceException in “Processing Jobs” page and possible client timeouts during peak loads when working with Redis Cluster.

This version brings a new method of parsing responses from Redis in .NET Core that works well even if CLR’s thread pool is starved. Dedicated reader threads now used for this purpose when running on Linux or macOS, but on Windows thread pool’s I/O threads now used instead to avoid spawning additional threads, since I/O threads work fine there. So upgrades are great for all of the operating systems.

This is a maintenance release that fixes serialization exception when trying to create a job continuation for batch in a batch continuation, disallows caching “JobStorage.Current is null” exceptions and let us to configure maximum number of entries for final batch state lists.

This release is unrelated to the previous ones and fixes wrong behavior when non-recommended max-memory policy is used in Redis, such as volatile-* one. I still don’t recommend to use other than noeviction policies, but at least the following case is handled better.

The new version brings a lot of improvements to the internal implementation of Hangfire.Pro.Redis itself and its underlying Redis client – ability to use multiple connections within the same storage, improved request/response processing pipeline, TLS 1.2 enabled by default for encrypted connections and other improvements and fixes.

These versions contain important fixes for Redis-based job storage implementation, including better handling of fail-over events in clustered environments, reduced number of timeout exceptions and better reliability for distributed locks.

This release fixes occasional timeout exceptions that occur when attaching nested batch continuations for nested batches that are currently processed. The exception occurred due to a deadlock caused by different batch lock acquisition order when nested batches are involved.

This is a maintenance release that plays better with recently released Hangfire 1.7, so you don’t get extra framework packages when targeting .NET Core or .NET Standard 2.0. Also, continuation filters now don’t throw an exception again and again, when continuation has already expired.

This version brings support for Mono on Linux and macOS platforms without the need to reference additional packages. On Windows, both .NET Framework and .NET Standard 2.0 now use the same methods for polling a socket for new data, to make the behavior consistent across platforms.

This is an important release that makes timeout detection much more robust. First of all, Redis server itself now acts as a single time authority for performing timeout checks for both jobs and servers rather than UTC time of a current Hangfire Server. So you don’t need to use synchronized clocks to prevent false positives for timeout checks.

This release fixes unexpected behaviors when we are cancelling a batch that has continuations for its inner items as in the following sample. When those continuations have continuations themselves, or when we attaching a job with continuation to a cancelled batch, our leaf-level continuations stuck in the awaiting or non-initialized state until queued manually.

The goal of this release is to resolve the timeout issues that appear in .NET Core 2.X applications. Such behavior was caused by networking implementation of SE.Redis, which posted Redis response processing logic to thread pool’s worker threads, instead of completion ports or custom threads, due to the lack of the corresponding API in netstandard1.X specification.

This maintenance release fixes race condition in the UseBatches method that can lead to the InvalidOperationException with “Batches are not initialized” message.

This release solves connectivity issues with Redis Cluster 4.X, appeared as a result of breaking changes introduced in Redis 4.0.

This release brings full support for continuations in batches, including the nested ones. Now you can create continuations within a batch even for jobs or batches in nested batches. Consider the following sample:

This is a minor update that fixes VS Code debugger crash on OS X, and don’t report ThreadAbortException as fatal. You can update only if these issues annoys you.

Another bug related to forever incomplete batches has been fixed. This bug existed for a long time, so I’d recommend anyone to upgrade.

This release contains the most amazing update to the batches feature. Now you can create nested batches, attach jobs or batches to an existing batch, regardless of its current state, and lazily cancel running batches. Also, you can create job continuation for batch, and batch continuation for job. These feature allows you to build powerful workflows on top of Hangfire with ease.

Redis Cluster is finally supported. Also improved connection resilience using custom connection loop, upgraded StackExchange.Redis to the latest version and fixed some nasty bugs. So I’d recommend to upgrade, especially if you are using Redis in cloud environments.

​There was a lack of distributed lock during the batch creation phase. If an antecedent batch succeeded just after adding a batch continuation (continuations:finished set), but before the continuation was created, antecedent batch was silently ignoring the fact that continuation does not exist yet. ​I’ve added a required distributed lock, and taught a state filter related to continuations to throw an exception, when continuation doesn’t exist.

Finally Redis Cluster is officially supported by Hangfire.Pro.Redis package, and correctly handles the corner cases of Redis’ async replication. I was able to implement it without requiring RedLock algorithm, regular WATCH commands are used to ensure distributed lock correctness.

This is a correcting release that mainly fixes regression related to dashboard, appeared in the previous version.

I’m very excited to write about all of these changes, because they take batches and Hangfire itself to a whole new level by unlocking a lot of usage scenarios. This pre-release adds support for nested batches, modifications of existing batches, batch continuations for jobs and vice versa, batch cancellation as well as support for .NET Standard and configurable batch expiration time.

This release contains a bunch of fixes for batches, and is recommended for anyone who use them. Batches now always created in a correct state (Started, Completed or Succeeded), depending of state of its jobs. This is the most important change that fixes weird problems with batches that hanging forever.

This is a correcting release that fixes Server.StartedAt field reset problem during each server heartbeat, which lead to confusion that servers are constantly restarted, when watching the Servers page. It also adds missing GetValueFromHash method required by popular Hangfire.Console extension.

This is a maintenance release that add support for Hangfire.Core 1.4.0 for conservative users who are planning to switch to use a more stable StackExchange.Redis client package, but don’t want to upgrade Hangfire.Core. Originally this package supported only ≥ 1.5.0 versions.

This is a maintenance release that fixes ArgumentNullException that appears in Dashboard UI and during a call to the RedisMonitoringApi.Servers method, when BackgroundJobServer instance was resurrected. Resurrection happens when a server was removed from active servers list due to network problems, but then appeared again.

This release adds an option that explicitly allows using multiple endpoints in the connection string, but it’s not recommended. Use it at your own risk! Here’s a small explanation:

This release brings us a single package that targets both .NET Framework and .NET Core, so there’s no need to use separate packages now. It also fixes a rare issue, when a timed out background job stays in the processing set indefinitely, causing dashboard exceptions.

Brand new version of Hangfire.Pro.Redis is finally available. It is now based on feature-rich StackExchange.Redis library, allowing us to bring Hangfire to more environments that use Redis storage in the near future. This version comes with some new features, including SSL support and highly reduced connection usage.

This version fixes different problems, that caused batches and batch continuations appear with no background jobs under rare circumstances. Also, background jobs now have the same expiration time with the batch itself. It is highly recommended to upgrade, if you are using batches.

New major version of Hangfire.Pro.Redis package (a part of Hangfire Pro) is almost here. Now it uses popular open-source library StackExchange.Redis to interact with Redis – a blazing fast data structure store.

This release fixes distributed locks in Hangfire.Pro.Redis that didn’t take the Prefix option into account. This may result in problems and different timeout when a single Redis instance is used for a bunch of applications with separate code base.

This release fixes an issue with batch continuations, and is recommended for anyone who use them. The issue takes place, when a parent batch unable to complete within 1 hour, after which batch continuation may start with no jobs, because all of them were expired.

This release fixes Could not find type Hangfire.Batches.States.BatchAwaitingState exception appeared after upgrading from Hangfire Pro 1.4.0 or 1.4.1 when using batch continuations. Previous release solved the issue partly, and didn’t cover those who just updated from versions listed above.

This release fixes a security issue that caused Redis password leaks to log targets during the Hangfire Server startup. The password was also shown in dashboard. If you are using password-protected Redis, it is highly recommended to update to this release, and change Redis password.

New versions of Hangfire Pro packages released to be compatible with Hangfire 1.5.0 version. Background jobs in batches now performing slightly faster, and Redis transaction scope was reduced to the Commit method, allowing to query for data from apply state filters.

This is a correcting release that fixes a race condition related to batch continuations and slightly improves performance of a batch job processing, especially when using SQL Server. It is strongly recommended to upgrade.

This release makes some hard-coded values (like maximum succeeded job list length) configurable through the RedisStorageOptions class. It also helps to re-queue aborted background jobs earlier – instead of waiting for invisibility timeout after non-graceful shutdown, we are re-queueing aborted background jobs right after its server becomes inactive.

This is a correcting release that fixes job prioritization via queue ordering in an instance of the BackgroundJobServerOptions class and adds support for symbol packages.

After a long development, batches and batch continuations are completed, and I’m glad to introduce these features. It was a real challenge for me and for Hangfire to implement these features as a regular extension. If you don’t share my joy (Batches? Why I need them?), I’ll show you why they are so important.