Logs show that Lambda ran completely, but function exits with exit status 1

Here is my code:

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/aws/aws-sdk-go-v2/config"
    "github.com/aws/aws-sdk-go-v2/service/ec2"
    "github.com/aws/aws-sdk-go-v2/service/ec2/types"
)

func main() {
    // Load the Shared AWS Configuration (~/.aws/config)
    cfg, err := config.LoadDefaultConfig(context.TODO())
    if err != nil {
        log.Fatal(err)
    }

    // Create an Amazon EC2 service client
    ec2ServiceClient := ec2.NewFromConfig(cfg)

    // DescribeAddressesInput with no filter means list all addresses
    IpListFilter := &ec2.DescribeAddressesInput{}

    // Ask EC2 client to list all Elastic IPs.
    result, err := ec2ServiceClient.DescribeAddresses(context.TODO(), IpListFilter)
    if err != nil {
        fmt.Println("Got an error retrieving information about your Amazon Elastic IPs:")
        fmt.Println(err)
        return
    }

    // Out of all IPs, check if they have an allocation ID. If not, they are candidate for deletion
    for _, a := range result.Addresses {
        fmt.Println("Allocation ID: " + *a.AllocationId)
        fmt.Println("Public IP: " + *a.PublicIp)

        // if this EIP is not associated with any AWS resources, proceed for killing.
        if a.AssociationId == nil {
            // extra step for flexibility
            if isThisEIPKillable(a.Tags) {
                fmt.Println("About to be killed")
                // Release/kill the Elastic IP
                ReleaseAddressFilter := &ec2.ReleaseAddressInput{AllocationId: a.AllocationId}
                ec2ServiceClient.ReleaseAddress(context.TODO(), ReleaseAddressFilter)
                fmt.Println(*a.PublicIp + " is not more")
            } else {
                fmt.Println(*a.PublicIp + " has KILLERHOLD enabled and is going to stay")
            }

        } else {
            fmt.Println("Association ID: " + *a.AssociationId)
            fmt.Println("Instance ID: " + *a.InstanceId)
            fmt.Println("PrivateIpAddress: " + *a.PrivateIpAddress)
        }

        fmt.Println("")
    }
}

// isThisEIPKillable scans to tags of Elastic IP and only return false when
// EIPKILLER is tag is set to true.
func isThisEIPKillable(tags []types.Tag) bool {
    for _, tag := range tags {
        if *tag.Key == "KILLERHOLD" && *tag.Value == "true" {
            return false
        }
    }
    return true
}

The Lambda function has the necessary permission to run i.e. it is allowed to run ec2:ReleaseAddress and ec2:DescribeAddresses.

For testing, I have one EIP associated with one EC2 instance. According to the Lambda logic, the lambda should just print output and exit without any error.

But this is what happens. I have redacted some strings for privacy:

START RequestId: 5a7446ed-6896-4e65-b795-35d1bfd6ca60 Version: $LATEST
Allocation ID: eipalloc-08fexample952a7f7
Public IP: XXX.XXX.XXX.XXX
Association ID: eipassoc-0112e332e17959d76
Instance ID: i-096561051e41c2d60
PrivateIpAddress: 10.2.1.38
2022/08/26 14:25:38 <nil>
Allocation ID: eipalloc-08fexample952a7f7
Public IP: XXX.XXX.XXX.XXX
Association ID: eipassoc-011example959d76
Instance ID: i-09656examplec2d60
PrivateIpAddress: 10.2.1.38
2022/08/26 14:25:39 <nil>
END RequestId: 5a7446ed-6896-4e65-b795-3exampleca60
REPORT RequestId: 5a7446ed-6896-4e65-b795-3examplea60	Duration: 402.33 ms	Billed Duration: 403 ms	Memory Size: 512 MB	Max Memory Used: 21 MB	
RequestId: 5a7446ed-6896-4e65-b795-3exampleca60 Error: Runtime exited with error: exit status 1
Runtime.ExitError

As figured out by @jarmod and @Daniel. The function you have written does not comply with the format prescribed in the docs.

Assuming that you have configured your handler to be main, here is a diff of your old code vs what it should be.

@@ -5,14 +5,19 @@ import (
        "fmt"
        "log"
 
+       "github.com/aws/aws-lambda-go/lambda"
        "github.com/aws/aws-sdk-go-v2/config"
        "github.com/aws/aws-sdk-go-v2/service/ec2"
        "github.com/aws/aws-sdk-go-v2/service/ec2/types"
 )
 
-func main() {
+type MyEvent struct {
+       Name string `json:"name"`
+}
+
+func Handler(ctx context.Context, name MyEvent) (string, error) {
        // Load the Shared AWS Configuration (~/.aws/config)
-       cfg, err := config.LoadDefaultConfig(context.TODO())
+       cfg, err := config.LoadDefaultConfig(ctx)
        if err != nil {
                log.Fatal(err)
        }
@@ -27,8 +32,7 @@ func main() {
        result, err := ec2ServiceClient.DescribeAddresses(context.TODO(), IpListFilter)
        if err != nil {
                fmt.Println("Got an error retrieving information about your Amazon Elastic IPs:")
-               fmt.Println(err)
-               return
+               return "", err
        }
 
        // Out of all IPs, check if they have an allocation ID. If not, they are candidate for deletion
@@ -57,6 +61,7 @@ func main() {
 
                fmt.Println("")
        }
+       return "Done execution", nil
 }
 
 // isThisEIPKillable scans to tags of Elastic IP and only return false when
@@ -69,3 +74,7 @@ func isThisEIPKillable(tags []types.Tag) bool {
        }
        return true
 }
+
+func main() {
+       lambda.Start(Handler)
+}

Basically move all the logic to a different function say Handler, and then invoke that function in main using lambda.Start(Handler)

Refer to AWS Lambda function handler in Go for reference.