[BUG] Deployment.FailureEncountered Does Not Populate as Expected (Always False)

[kurtislamb]

Description
When calling Deployments.GetDeployment the returned data incorrectly shows FailureEncountered as False even if the deployment indeed failed.

Steps To Reproduce
1.Init a Client
2.Create a projects.Project struct eg octopusProjectData.project in below code
3.Use code below to get all releases for a project then iterate through each release, then iterate through each deployment

releaseInfo, err := client.Projects.GetReleases(octopusProjectData.project)
	if err != nil {
		return latestSuccessfulRelease, fmt.Errorf("failed to lookup Release data: %w", err)
	}

	for _, release := range releaseInfo {
		log.Println("Release Version:", release.Version)
		deployments, err := client.Deployments.GetDeployments(release)
		for _, deployment := range deployments.Items {
                        log.Println(release.Version)
			log.Println(deployment.ID)
			log.Println(deployment.FailureEncountered, "\n")
		}
	}

Expected Behavior
If a deployment for a release has failed, I would expect FailureEncountered to return true, so we can then disregard this deployment.

First 2 should show as True (A Failure was Encountered)

2025/01/03 08:46:45 KL-2025.0.3
2025/01/03 08:46:45 Deployments-1478
2025/01/03 08:46:45 true

2025/01/03 08:46:45 KL-2025.0.2
2025/01/03 08:46:45 Deployments-1477
2025/01/03 08:46:45 true

2025/01/03 08:46:45 KL-2025.0.1
2025/01/03 08:46:45 Deployments-1474
2025/01/03 08:46:45 false 

Any Logs and/or Other Supporting Information

Output From Octopus Deploy, I would expect .0.3 and .0.2 to return as failed

Output from GO

2025/01/03 08:46:45 KL-2025.0.3
2025/01/03 08:46:45 Deployments-1478
2025/01/03 08:46:45 false 

2025/01/03 08:46:45 KL-2025.0.2
2025/01/03 08:46:45 Deployments-1477
2025/01/03 08:46:45 false 

2025/01/03 08:46:45 KL-2025.0.1
2025/01/03 08:46:45 Deployments-1474
2025/01/03 08:46:45 false 

Environment and/or Versions

• Octopus Server Version: Octopus 2025.1 - Cloud
• Go Version: go1.23.0 linux/amd64

Additional Context
The approach of the above code is to find the last Deployment for a Project, iterating through releases and their deployments.

[NickJosevski]

Thanks for the detailed report — the reproduction and the side-by-side output made this quick to trace.

This isn't a client bug. go-octopusdeploy is faithfully deserializing what the API sends; the API is genuinely sending FailureEncountered: false for those deployments. You'd see the same from the .NET client, the Terraform provider, or a raw curl.

Why

On the Server, FailureEncountered is derived from the deployment's in-flight execution plan state rather than stored as a fact about the outcome:

DeploymentResource.FailureEncountered
  <- Deployment.FailureEncountered
  <- StateObject != null && StateObject.FailureEncountered

When a deployment finishes — success or failure — the completion path calls ClearState(), which sets StateObject to null to keep the document small (that blob holds planned steps, acquired packages and so on). With StateObject null, the expression collapses to false.

So the field can only ever read true for a deployment that is still running or paused — one sitting in a guided-failure interruption, for example. For any completed deployment it is always false, which is exactly what you're seeing. It's longstanding behaviour, not a recent regression.

What to use instead

Read the outcome from the server task the deployment points at. Deployment.TaskID gives you the task ID, and the task's State is the authoritative signal — it's what the Octopus web portal uses to render the red and green icons in your screenshot.

Since your loop already has a batch of deployments in hand, you can resolve them in one call rather than one per deployment:

taskIDs := make([]string, 0, len(deployments.Items))
for _, deployment := range deployments.Items {
    taskIDs = append(taskIDs, deployment.TaskID)
}

taskResults, err := client.Tasks.Get(tasks.TasksQuery{IDs: taskIDs})
if err != nil {
    return latestSuccessfulRelease, fmt.Errorf("failed to look up deployment tasks: %w", err)
}

for _, task := range taskResults.Items {
    log.Println(release.Version, task.ID, task.State)
}

task.State is a string, one of Queued, Executing, Failed, Canceled, TimedOut, Success, Cancelling. For your goal — finding the last successful deployment — task.State == "Success" is the check you want. There's also task.FinishedSuccessfully, but note it's a *bool, so it needs a nil check before dereferencing; the State comparison is less fiddly.

Worth knowing: TasksQuery supports Project and States directly, so if all you need is the most recent successful deployment for a project, you can skip the releases-then-deployments walk entirely and query tasks for that project with States: []string{"Success"}, newest first.

Server-side follow-up

I've raised OctopusDeploy/Issues#10183 to track the Server behaviour.

Setting expectations honestly on that: even if we make the field truthful going forward, it can't be backfilled — the plan state for your existing deployments is already gone, so historical deployments would keep returning false. There's also a real question about what the field should mean, since the underlying flag is set on cancellation too and is never reset once set. The task-based approach above is the durable answer regardless of how that lands.

Leaving this open until the Server issue is resolved, since there may be a docs note or a deprecation to make on the client side once it is.