// RetryRules returns the delay duration before retrying this request again
func (d DefaultRetryer) RetryRules(r *request.Request) time.Duration {


	// if number of max retries is zero, no retries will be performed.
	if d.NumMaxRetries == 0 {
		return 0
	}


	// Sets default value for retryer members
	d.setRetryerDefaults()


	// minDelay is the minimum retryer delay
	minDelay := d.MinRetryDelay


	var initialDelay time.Duration


	isThrottle := r.IsErrorThrottle()
	if isThrottle {
		if delay, ok := getRetryAfterDelay(r); ok {
			initialDelay = delay
		}
		minDelay = d.MinThrottleDelay
	}


	retryCount := r.RetryCount


	// maxDelay the maximum retryer delay
	maxDelay := d.MaxRetryDelay


	if isThrottle {
		maxDelay = d.MaxThrottleDelay
	}


	var delay time.Duration


	// Logic to cap the retry count based on the minDelay provided
	actualRetryCount := int(math.Log2(float64(minDelay))) + 1
	if actualRetryCount < 63-retryCount {
		delay = time.Duration(1<<uint64(retryCount)) * getJitterDelay(minDelay)
		if delay > maxDelay {
			delay = getJitterDelay(maxDelay / 2)
		}
	} else {
		delay = getJitterDelay(maxDelay / 2)
	}
	return delay + initialDelay
}

type Config struct {
	// ...
	// Retryer guides how HTTP requests should be retried in case of
	// recoverable failures.
	//
	// When nil or the value does not implement the request.Retryer interface,
	// the client.DefaultRetryer will be used.
	//
	// When both Retryer and MaxRetries are non-nil, the former is used and
	// the latter ignored.
	//
	// To set the Retryer field in a type-safe manner and with chaining, use
	// the request.WithRetryer helper function:
	//
	//   cfg := request.WithRetryer(aws.NewConfig(), myRetryer)
	//
	Retryer RequestRetryer
	// ...
}

package sample

import (
	"context"
	"time"

	"github.com/aws/aws-sdk-go/aws/client"
	"github.com/aws/aws-sdk-go/aws/request"
	"github.com/jpillora/backoff"
)

type customRetryer struct {
	*backoff.Backoff
	client.DefaultRetryer
}

func NewCustomRetryer(cfg *backoff.Backoff, numRetries int) *customRetryer {
	r := &customRetryer{Backoff: cfg}
	r.NumMaxRetries = numRetries
	return r
}

func (cr customRetryer) RetryRules(req *request.Request) time.Duration {
	return cr.Backoff.Duration()
}

var _ request.Retryer = &customRetryer{}

package main

import (
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/endpoints"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/lambda"
	"github.com/d-tsuji/go-sandbox/customretry/sample"
	"github.com/jpillora/backoff"
)

var (
	lmd         *lambda.Lambda
	maxRetryNum = 10 // リトライ上限回数は環境変数などから取得
)

func init() {
	lmd = lambda.New(session.Must(session.NewSession(&aws.Config{
		Region:     aws.String(endpoints.ApNortheast1RegionID),
		MaxRetries: aws.Int(maxRetryNum),
		Retryer: sample.NewCustomRetryer(&backoff.Backoff{
			Min:    10 * time.Millisecond,
			Max:    300 * time.Millisecond,
			Factor: 2,
			Jitter: true,
		}, maxRetryNum),
	})))
}