return cfg, err
		}
		if queueSize <= 0 {
			return cfg, errInvalidQueueSize
		}
		batchSizeCfgVal := getCfgVal(EnvLoggerWebhookBatchSize, k, kv.Get(BatchSize))
		batchSize, err := strconv.Atoi(batchSizeCfgVal)
		if err != nil {
			return cfg, err
		}
		if batchSize <= 0 {
			return cfg, errInvalidBatchSize
		}
		maxRetryCfgVal := getCfgVal(EnvLoggerWebhookMaxRetry, k, kv.Get(MaxRetry))

	QueueDir           string        `json:"queueDir"`
	QueueLimit         uint64        `json:"queueLimit"`
	Version            string        `json:"version"`
	BatchSize          uint32        `json:"batchSize"`
	BatchCommitTimeout time.Duration `json:"batchCommitTimeout"`
	TLS                struct {
		Enable        bool               `json:"enable"`
		RootCAs       *x509.CertPool     `json:"-"`

		} else if result.Error != nil {
			tx.AddError(result.Error)
		}

		if tx.Error != nil || int(result.RowsAffected) < batchSize {
			break
		}

		if totalSize > 0 {
			if totalSize <= int(rowsAffected) {
				break
			}
			if totalSize/batchSize == batch {
				batchSize = totalSize % batchSize
			}
		}

		// Optimize for-break
		resultsValue := reflect.Indirect(reflect.ValueOf(dest))

func New(config Config) (*Target, error) {
	maxWorkers := maxWorkers
	if config.BatchSize > 100 {
		maxWorkers = maxWorkersWithBatchEvents
	} else if config.BatchSize <= 0 {
		config.BatchSize = 1
	}

	h := &Target{
		logCh:       make(chan interface{}, config.QueueSize),
		config:      config,
		batchSize:   config.BatchSize,
		maxWorkers:  int64(maxWorkers),
		httpTimeout: config.HTTPTimeout,
	}

        final SearchLogBhv searchLogBhv = ComponentUtil.getComponent(SearchLogBhv.class);
        final int batchSize = ComponentUtil.getFessConfig().getSearchlogProcessBatchSizeAsInteger();
        final int totalSize = searchLogList.size();
        for (int i = 0; i < totalSize; i += batchSize) {
            final int end = Math.min(totalSize, i + batchSize);
            if (logger.isDebugEnabled()) {

			Key:         ClientKey,
			Description: "mTLS certificate key for webhook authentication",
			Optional:    true,
			Type:        "string",
			Sensitive:   true,
		},
		config.HelpKV{
			Key:         BatchSize,
			Description: "Number of events per HTTP send to webhook target",
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         QueueSize,

	const BatchSize = 250 // We process the objects in batches - 250 is a reasonable default.
	var (
		metadata = make([]map[string]string, 0, BatchSize)
		buckets  = make([]string, 0, BatchSize)
		names    = make([]string, 0, BatchSize)
	)
	for len(objects) > 0 {
		N := BatchSize
		if len(objects) < BatchSize {
			N = len(objects)
		}
		batch := objects[:N]

			QueueDir:           env.Get(queueDirEnv, kv.Get(target.KafkaQueueDir)),
			QueueLimit:         queueLimit,
			Version:            env.Get(versionEnv, kv.Get(target.KafkaVersion)),
			BatchSize:          uint32(batchSize),
			BatchCommitTimeout: batchCommitTimeout,
		}

		tlsEnableEnv := target.EnvKafkaTLS
		if k != config.Default {
			tlsEnableEnv = tlsEnableEnv + config.Default + k
		}

	}

	targetUsers := users[3:8]
	for i := 0; i < len(targetUsers); i++ {
		AssertEqual(t, results[i], targetUsers[i])
	}

	var sub1 []User
	// limit < batchSize
	if result := DB.Limit(5).Where("name = ?", users[0].Name).FindInBatches(&sub1, 10, func(tx *gorm.DB, batch int) error {
		return nil
	}); result.Error != nil || result.RowsAffected != 5 {