feat: some optimize

.github/workflows/benchmark.yml

@@ -0,0 +1,102 @@
+name: Benchmark
+on:
+  push:
+    branches:
+      - master
+    paths-ignore:
+      - "**/*.md"
+  pull_request:
+    paths-ignore:
+      - "**/*.md"
+permissions:
+  contents: write
+  pull-requests: write
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fetch Repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # to be able to retrieve the last commit
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          # NOTE: Keep this in sync with the version from go.mod
+          go-version: "1.22.x"
+
+      - name: Run Benchmark
+        run: set -o pipefail; go test ./... -benchmem -run=^$ -bench . | tee output.txt
+
+      # NOTE: Benchmarks could change with different CPU types
+      - name: Get GitHub Runner System Information
+        uses: kenchan0130/[email protected]
+        id: system-info
+
+      - name: Get Main branch SHA
+        id: get-master-branch-sha
+        run: |
+          SHA=$(git rev-parse origin/master)
+          echo "sha=$SHA" >> $GITHUB_OUTPUT
+
+      - name: Get Benchmark Results from master branch
+        id: cache
+        uses: actions/cache/restore@v4
+        with:
+          path: ./cache
+          key: ${{ steps.get-master-branch-sha.outputs.sha }}-${{ runner.os }}-${{ steps.system-info.outputs.cpu-model }}-benchmark
+
+      # This will only run if we have Benchmark Results from master branch
+      - name: Compare PR Benchmark Results with master branch
+        uses: benchmark-action/[email protected]
+        if: steps.cache.outputs.cache-hit == 'true'
+        with:
+          tool: 'go'
+          output-file-path: output.txt
+          external-data-json-path: ./cache/benchmark-data.json
+          # Do not save the data (This allows comparing benchmarks)
+          save-data-file: false
+          fail-on-alert: true
+          # Comment on the PR if the branch is not a fork
+          comment-on-alert: ${{ github.event.pull_request.head.repo.fork == false }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          summary-always: true
+          alert-threshold: "150%"
+
+      - name: Store Benchmark Results for master branch
+        uses: benchmark-action/[email protected]
+        if: ${{ github.ref_name == 'master' }}
+        with:
+          tool: 'go'
+          output-file-path: output.txt
+          external-data-json-path: ./cache/benchmark-data.json
+          # Save the data to external file (cache)
+          save-data-file: true
+          fail-on-alert: false
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          summary-always: true
+          alert-threshold: "150%"
+
+      - name: Publish Benchmark Results to GitHub Pages
+        uses: benchmark-action/[email protected]
+        if: ${{ github.ref_name == 'master' }}
+        with:
+          tool: 'go'
+          output-file-path: output.txt
+          benchmark-data-dir-path: "benchmarks"
+          fail-on-alert: false
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          comment-on-alert: true
+          summary-always: true
+          # Save the data to external file (GitHub Pages)
+          save-data-file: true
+          alert-threshold: "150%"
+          auto-push: false
+
+      - name: Update Benchmark Results cache
+        uses: actions/cache/save@v4
+        if: ${{ github.ref_name == 'master' }}
+        with:
+          path: ./cache
+          key: ${{ steps.get-master-branch-sha.outputs.sha }}-${{ runner.os }}-${{ steps.system-info.outputs.cpu-model }}-benchmark

.github/workflows/mockery.yml

@@ -1,6 +1,9 @@
 name: Mockery
 on:
   pull_request:
+permissions:
+  contents: write
+  pull-requests: write
 jobs:
   mockery:
     runs-on: ubuntu-latest

contracts/session/manager.go

@@ -6,5 +6,5 @@ type Manager interface {
 	// Driver retrieves the session driver by name.
 	Driver(name ...string) (Driver, error)
 	// Extend extends the session manager with a custom driver.
-	Extend(driver string, handler func() Driver) Manager
+	Extend(driver string, handler func() Driver) (Manager, error)
 }

crypt/aes_test.go

@@ -57,3 +57,35 @@ func (s *AesTestSuite) TestDecryptString() {
 	_, err = s.aes.DecryptString("eyJpdiI6IjEyMzQ1IiwidmFsdWUiOiIxMjM0NSJ9")
 	s.Error(err)
 }
+
+func Benchmark_EncryptString(b *testing.B) {
+	mockConfig := &configmock.Config{}
+	mockConfig.On("GetString", "app.key").Return("11111111111111111111111111111111").Once()
+	aes := NewAES(mockConfig, json.NewJson())
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_, err := aes.EncryptString("Goravel")
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func Benchmark_DecryptString(b *testing.B) {
+	mockConfig := &configmock.Config{}
+	mockConfig.On("GetString", "app.key").Return("11111111111111111111111111111111").Once()
+	aes := NewAES(mockConfig, json.NewJson())
+	payload, err := aes.EncryptString("Goravel")
+	if err != nil {
+		b.Error(err)
+	}
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		_, err := aes.DecryptString(payload)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}

foundation/application_test.go

@@ -401,6 +401,7 @@ func (s *ApplicationTestSuite) TestMakeSchedule() {
 func (s *ApplicationTestSuite) TestMakeSession() {
 	mockConfig := &configmocks.Config{}
 	mockConfig.On("GetInt", "session.lifetime").Return(120).Once()
+	mockConfig.On("GetInt", "session.gc_interval").Return(30).Once()
 	mockConfig.On("GetString", "session.files").Return("storage/framework/sessions").Once()
 
 	s.app.Singleton(frameworkconfig.Binding, func(app foundation.Application) (any, error) {

go.mod

@@ -1,6 +1,6 @@
 module github.com/goravel/framework
 
-go 1.21
+go 1.22
 
 require (
 	github.com/RichardKnop/machinery/v2 v2.0.13

hash/application_test.go

@@ -11,25 +11,24 @@ import (
 
 type ApplicationTestSuite struct {
 	suite.Suite
+	config  *configmock.Config
 	hashers map[string]hash.Hash
 }
 
 func TestApplicationTestSuite(t *testing.T) {
-	mockConfig := &configmock.Config{}
-	argon2idHasher := getArgon2idHasher(mockConfig)
-	bcryptHasher := getBcryptHasher(mockConfig)
-
-	suite.Run(t, &ApplicationTestSuite{
-		hashers: map[string]hash.Hash{
-			"argon2id": argon2idHasher,
-			"bcrypt":   bcryptHasher,
-		},
-	})
-	mockConfig.AssertExpectations(t)
+	suite.Run(t, &ApplicationTestSuite{})
 }
 
 func (s *ApplicationTestSuite) SetupTest() {
+	s.config = &configmock.Config{}
+	s.hashers = map[string]hash.Hash{
+		"argon2id": getArgon2idHasher(s.config),
+		"bcrypt":   getBcryptHasher(s.config),
+	}
+}
 
+func (s *ApplicationTestSuite) TearDownSuite() {
+	s.config.AssertExpectations(s.T())
 }
 
 func (s *ApplicationTestSuite) TestMakeHash() {
@@ -78,6 +77,67 @@ func (s *ApplicationTestSuite) TestNeedsRehash() {
 	}
 }
 
+func BenchmarkMakeHash(b *testing.B) {
+	s := new(ApplicationTestSuite)
+	s.SetT(&testing.T{})
+	s.SetupTest()
+	b.StartTimer()
+	b.ResetTimer()
+	for name, hasher := range s.hashers {
+		b.Run(name, func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				_, err := hasher.Make("password")
+				if err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+	b.StopTimer()
+}
+
+func BenchmarkCheckHash(b *testing.B) {
+	s := new(ApplicationTestSuite)
+	s.SetT(&testing.T{})
+	s.SetupTest()
+	b.StartTimer()
+	b.ResetTimer()
+	for name, hasher := range s.hashers {
+		b.Run(name, func(b *testing.B) {
+			value, err := hasher.Make("password")
+			if err != nil {
+				b.Fatal(err)
+			}
+			for i := 0; i < b.N; i++ {
+				if !hasher.Check("password", value) {
+					b.Fatal("hash check failed")
+				}
+			}
+		})
+	}
+	b.StopTimer()
+}
+
+func BenchmarkNeedsRehash(b *testing.B) {
+	s := new(ApplicationTestSuite)
+	s.SetT(&testing.T{})
+	s.SetupTest()
+	b.StartTimer()
+	b.ResetTimer()
+	for name, hasher := range s.hashers {
+		b.Run(name, func(b *testing.B) {
+			value, err := hasher.Make("password")
+			if err != nil {
+				b.Fatal(err)
+			}
+			for i := 0; i < b.N; i++ {
+				hasher.NeedsRehash(value)
+			}
+		})
+	}
+	b.StopTimer()
+}
+
 func getArgon2idHasher(mockConfig *configmock.Config) *Argon2id {
 	mockConfig.On("GetInt", "hashing.argon2id.memory", 65536).Return(65536).Once()
 	mockConfig.On("GetInt", "hashing.argon2id.time", 4).Return(4).Once()
@@ -87,7 +147,7 @@ func getArgon2idHasher(mockConfig *configmock.Config) *Argon2id {
 }
 
 func getBcryptHasher(mockConfig *configmock.Config) *Bcrypt {
-	mockConfig.On("GetInt", "hashing.bcrypt.rounds", 10).Return(10).Once()
+	mockConfig.On("GetInt", "hashing.bcrypt.rounds", 12).Return(10).Once()
 
 	return NewBcrypt(mockConfig)
 }

hash/bcrypt.go

@@ -13,7 +13,7 @@ type Bcrypt struct {
 // NewBcrypt returns a new Bcrypt hasher.
 func NewBcrypt(config config.Config) *Bcrypt {
 	return &Bcrypt{
-		rounds: config.GetInt("hashing.bcrypt.rounds", 10),
+		rounds: config.GetInt("hashing.bcrypt.rounds", 12),
 	}
 }
 

http/middleware/throttle_test.go

@@ -276,6 +276,88 @@ func TestThrottle(t *testing.T) {
 	}
 }
 
+func Benchmark_Throttle(b *testing.B) {
+	var (
+		ctx                   *TestContext
+		mockRateLimiterFacade *httpmocks.RateLimiter
+		mockCache             *cachemocks.Cache
+	)
+
+	now := carbon.Now()
+	carbon.SetTestNow(now)
+	defer carbon.UnsetTestNow()
+
+	ctx = new(TestContext)
+	mockCache = &cachemocks.Cache{}
+	mockRateLimiterFacade = &httpmocks.RateLimiter{}
+	http.CacheFacade = mockCache
+	http.RateLimiterFacade = mockRateLimiterFacade
+
+	b.Run("WithOneLimiter", func(b *testing.B) {
+		mockRateLimiterFacade.On("Limiter", "test").Return(func(ctx contractshttp.Context) []contractshttp.Limit {
+			return []contractshttp.Limit{
+				limit.PerDay(10),
+			}
+		}).Times(b.N)
+		mockCache.On("Get", mock.MatchedBy(func(key string) bool {
+			return strings.HasPrefix(key, "throttle:test:0:")
+		})).Return(limit.NewBucket(1, time.Minute)).Times(b.N)
+
+		for i := 0; i < b.N; i++ {
+			Throttle("test")(ctx)
+		}
+
+		mockCache.AssertExpectations(b)
+		mockRateLimiterFacade.AssertExpectations(b)
+	})
+
+	b.Run("WithTwoLimiters", func(b *testing.B) {
+		mockRateLimiterFacade.On("Limiter", "test").Return(func(ctx contractshttp.Context) []contractshttp.Limit {
+			return []contractshttp.Limit{
+				limit.PerDay(10),
+				limit.PerMinute(5),
+			}
+		}).Times(b.N)
+		mockCache.On("Get", mock.MatchedBy(func(key string) bool {
+			return strings.HasPrefix(key, "throttle:test:0:")
+		})).Return(limit.NewBucket(10, 24*time.Hour))
+		mockCache.On("Get", mock.MatchedBy(func(key string) bool {
+			return strings.HasPrefix(key, "throttle:test:1:")
+		})).Return(limit.NewBucket(5, time.Minute))
+
+		for i := 0; i < b.N; i++ {
+			Throttle("test")(ctx)
+		}
+
+		mockRateLimiterFacade.AssertExpectations(b)
+	})
+
+	b.Run("WithThreeLimiters", func(b *testing.B) {
+		mockRateLimiterFacade.On("Limiter", "test").Return(func(ctx contractshttp.Context) []contractshttp.Limit {
+			return []contractshttp.Limit{
+				limit.PerMinute(5),
+				limit.PerHour(10),
+				limit.PerDay(100),
+			}
+		}).Times(b.N)
+		mockCache.On("Get", mock.MatchedBy(func(key string) bool {
+			return strings.HasPrefix(key, "throttle:test:0:")
+		})).Return(limit.NewBucket(10, 24*time.Hour))
+		mockCache.On("Get", mock.MatchedBy(func(key string) bool {
+			return strings.HasPrefix(key, "throttle:test:1:")
+		})).Return(limit.NewBucket(5, time.Minute))
+		mockCache.On("Get", mock.MatchedBy(func(key string) bool {
+			return strings.HasPrefix(key, "throttle:test:2:")
+		})).Return(limit.NewBucket(1, time.Second))
+
+		for i := 0; i < b.N; i++ {
+			Throttle("test")(ctx)
+		}
+
+		mockRateLimiterFacade.AssertExpectations(b)
+	})
+}
+
 type TestContext struct {
 	response contractshttp.ContextResponse
 }

log/logger/daily.go

@@ -14,6 +14,7 @@ import (
 	"github.com/goravel/framework/contracts/foundation"
 	"github.com/goravel/framework/log/formatter"
 	"github.com/goravel/framework/support"
+	"github.com/goravel/framework/support/carbon"
 )
 
 type Daily struct {
@@ -43,6 +44,7 @@ func (daily *Daily) Handle(channel string) (logrus.Hook, error) {
 		logPath+"-%Y-%m-%d"+ext,
 		rotatelogs.WithRotationTime(time.Duration(24)*time.Hour),
 		rotatelogs.WithRotationCount(uint(daily.config.GetInt(channel+".days"))),
+		rotatelogs.WithClock(rotatelogs.NewClock(carbon.Now().StdTime())),
 	)
 	if err != nil {
 		return hook, errors.New("Config local file system for logger error: " + err.Error())