Terraform Lifecycle Error: Unexpected Retention Policy Unit Change

Oct 17, 2025 by ADMIN 67 views

Introduction

Hey guys! Ever run into a snag while using Terraform and Octopus Deploy? Specifically, an issue where applying a lifecycle resource throws an unexpected value change for your retention policy unit? You're not alone! This article dives deep into a common bug encountered when setting up lifecycle resources with release and Tentacle retention policies. We'll break down the problem, show you how to reproduce it, discuss the expected behavior, and provide detailed logs and environment information. So, if you're wrestling with Terraform and Octopus Deploy, keep reading – this might just be the solution you've been searching for!

Understanding the Bug

The core of the problem lies in how Terraform and the Octopus Deploy provider handle changes to the unit attribute within retention policies. When you define a lifecycle resource that includes both release and Tentacle retention policies, applying the configuration can sometimes lead to an error. This error pops up because Terraform detects an unexpected change in the unit value, specifically switching from "Days" to "Items". This inconsistency gums up the works, preventing your lifecycle resource from being created as intended. It’s like telling your robot to pick up a box, but it keeps changing its mind about whether to use its gripper or suction cup – frustrating, right?

Why This Happens

The root cause of this bug often stems from the way the Octopus Deploy provider interacts with Terraform's state management. Terraform keeps track of the state of your infrastructure, and when it detects a difference between the desired state (your configuration) and the actual state, it attempts to make changes. In this case, the provider might be incorrectly interpreting or updating the unit attribute during the apply process. This misinterpretation leads to Terraform thinking there's a change when there isn't, or vice versa, resulting in the dreaded error message. Imagine it as a game of telephone, where the message gets garbled between each player, and the final message is nothing like the original!

Steps to Reproduce the Error

Let's get our hands dirty and see how you can actually trigger this bug. By following these steps, you can confirm if you're facing the same issue and better understand the context.

Step-by-Step Guide

Define Your Lifecycle Resource: Start by creating a lifecycle resource in your Terraform configuration. This resource should include both release_retention_policy and tentacle_retention_policy blocks.
Configure Retention Policies: Within these blocks, set specific values. For the release_retention_policy, use the following settings:
```
  release_retention_policy {
    quantity_to_keep    = 0
    should_keep_forever = true // true only if quantity_to_keep = 0
    unit                = "Days"
  }
```
For the tentacle_retention_policy, configure it like this:
```
  tentacle_retention_policy {
    quantity_to_keep    = 30
    should_keep_forever = false
    unit                = "Items"
  }
```
Important: Pay close attention to the unit attribute. The discrepancy between "Days" and "Items" is key to triggering the bug. Setting quantity_to_keep to 0 and should_keep_forever to true in the release_retention_policy is crucial, as this combination often exacerbates the issue.
Apply the Configuration: Now, run terraform apply to apply your configuration. This is where the magic (or rather, the error) happens.

Witness the Boom: If you're experiencing the bug, you'll see an error message similar to this:

Error: Provider produced inconsistent result after apply

When applying changes to octopusdeploy_lifecycle.example, provider
"provider["registry.terraform.io/octopusdeploy/octopusdeploy"]" produced an unexpected new value:
.release_retention_policy[0].unit: was cty.StringVal("Days"), but now cty.StringVal("Items").

This is a bug in the provider, which should be reported in the provider's own issue tracker.

Breaking it Down

So, what's actually happening here? Terraform is trying to create the lifecycle resource, but the Octopus Deploy provider is reporting an unexpected change in the unit attribute of the release_retention_policy. It was set to "Days", but now the provider is saying it's "Items". This inconsistency throws a wrench in the works, causing the apply process to fail. Think of it like trying to fit a square peg in a round hole – it just doesn't work!

Expected Behavior

Ideally, when you apply the Terraform configuration, the lifecycle resource should be created without any hiccups. The retention policies, both for releases and Tentacles, should be set exactly as you've defined them in your configuration. This means the unit attribute should remain consistent throughout the process, with "Days" staying "Days" and "Items" staying "Items".

Smooth Sailing

In a perfect world, Terraform would create the lifecycle with the specified retention policies, and you'd be off to the races, deploying your applications without a second thought. The release_retention_policy would correctly retain releases based on the number of days, and the tentacle_retention_policy would manage Tentacle retention based on the number of items. No errors, no inconsistencies, just smooth sailing. It’s like having a well-oiled machine – everything works together in perfect harmony!

Analyzing the Error Message

Let's dissect the error message we encountered earlier. Understanding the message is key to diagnosing the problem and finding a solution. The error message we saw was:

Error: Provider produced inconsistent result after apply

When applying changes to octopusdeploy_lifecycle.example, provider
"provider["registry.terraform.io/octopusdeploy/octopusdeploy"]" produced an unexpected new value:
.release_retention_policy[0].unit: was cty.StringVal("Days"), but now cty.StringVal("Items").

This is a bug in the provider, which should be reported in the provider's own issue tracker.

What Does It Mean?

This error message is telling us a few crucial things:

Inconsistent Result: The provider (in this case, the Octopus Deploy provider) has produced an inconsistent result after the apply operation. This means that what Terraform thought it was applying doesn't match what the provider actually did.
Specific Resource: The issue is happening within the octopusdeploy_lifecycle.example resource. This tells us exactly where to focus our attention.
Unexpected Value Change: The heart of the problem is the unexpected change in the release_retention_policy[0].unit attribute. It was "Days", but now it's "Items". This is the core inconsistency that's causing the error.
Provider Bug: The message explicitly states that this is likely a bug in the provider itself. This is a critical piece of information, as it suggests the issue might not be in your configuration, but rather in the provider's code.
Report the Issue: The message also advises reporting the bug to the provider's issue tracker. This is important because it helps the provider's developers become aware of the problem and work on a fix.

Deciphering the Message

Think of this error message as a detective giving you clues. It's pointing you to the specific resource, the exact attribute that's causing trouble, and even suggesting the likely culprit (the provider). By understanding these clues, you can start to formulate a plan of action. It's like reading a map – the error message is your guide to navigating the problem!

Environment and Versions

To fully understand the context of this bug, it's essential to consider the environment and versions involved. Here's the typical setup where this issue has been observed:

Operating System: Windows
Octopus Server Version: 2025.4.4166
Terraform Version: 1.13.3
Octopus Terraform Provider Version: 1.3.11

Why This Matters

These details are crucial because bugs can be specific to certain versions or environments. What works perfectly in one setup might fail miserably in another. By knowing the versions of the tools involved, you can narrow down the potential causes and search for solutions that are relevant to your specific situation.

For example, if you find that this bug is prevalent in Octopus Server Version 2025.4.4166, you might consider upgrading to a newer version where the issue is resolved. Similarly, if a particular version of the Octopus Terraform Provider is known to have this problem, you might try downgrading or upgrading to a different version. It’s like having a toolbox – you need to know which tools are compatible with the job at hand!

Conclusion

So, guys, we've taken a deep dive into this Terraform and Octopus Deploy bug, dissecting the error, understanding the steps to reproduce it, and analyzing the environment where it occurs. This bug, where applying a lifecycle resource leads to an unexpected change in the retention policy unit, can be a real head-scratcher. But armed with this knowledge, you're well-equipped to tackle it. Remember to check your configurations, verify your versions, and if necessary, report the issue to the provider. Happy Terraforming!