Add synchronous mode for serverless environments

src/StatsdClient/Bufferize/IStatsBufferize.cs

@@ -0,0 +1,17 @@
+using System;
+using StatsdClient.Statistic;
+
+namespace StatsdClient.Bufferize
+{
+    /// <summary>
+    /// IStatsBufferize defines the contract for sending stats to the pipeline.
+    /// </summary>
+    internal interface IStatsBufferize : IDisposable
+    {
+        bool TryDequeueFromPool(out Stats stats);
+
+        void Send(Stats stats);
+
+        void Flush();
+    }
+}

src/StatsdClient/Bufferize/IStatsBufferizeFactory.cs

@@ -12,7 +12,7 @@ namespace StatsdClient.Bufferize
     /// </summary>
     internal interface IStatsBufferizeFactory
     {
-        StatsBufferize CreateStatsBufferize(
+        IStatsBufferize CreateStatsBufferize(
           StatsRouter statsRouter,
           int workerMaxItemCount,
           TimeSpan? blockingQueueTimeout,
@@ -38,6 +38,7 @@ Telemetry CreateTelemetry(
             TimeSpan flushInterval,
             ITransport transport,
             string[] globalTags,
-            Action<Exception> optionalExceptionHandler);
+            Action<Exception> optionalExceptionHandler,
+            bool synchronousMode = false);
     }
 }

src/StatsdClient/Bufferize/StatsBufferize.cs

@@ -7,7 +7,7 @@ namespace StatsdClient.Bufferize
     /// <summary>
     /// StatsBufferize bufferizes metrics before sending them.
     /// </summary>
-    internal class StatsBufferize : IDisposable
+    internal class StatsBufferize : IStatsBufferize
     {
         private readonly AsynchronousWorker<Stats> _worker;
 

src/StatsdClient/Bufferize/StatsBufferizeFactory.cs

@@ -8,7 +8,7 @@ namespace StatsdClient.Bufferize
 {
     internal class StatsBufferizeFactory : IStatsBufferizeFactory
     {
-        public StatsBufferize CreateStatsBufferize(
+        public IStatsBufferize CreateStatsBufferize(
             StatsRouter statsRouter,
             int workerMaxItemCount,
             TimeSpan? blockingQueueTimeout,
@@ -49,9 +49,10 @@ public Telemetry CreateTelemetry(
             TimeSpan flushInterval,
             ITransport transport,
             string[] globalTags,
-            Action<Exception> optionalExceptionHandler)
+            Action<Exception> optionalExceptionHandler,
+            bool synchronousMode = false)
         {
-            return new Telemetry(metricSerializer, assemblyVersion, flushInterval, transport, globalTags, optionalExceptionHandler);
+            return new Telemetry(metricSerializer, assemblyVersion, flushInterval, transport, globalTags, optionalExceptionHandler, synchronousMode);
         }
 
         public ITransport CreateNamedPipeTransport(string pipeName)

src/StatsdClient/Bufferize/SynchronousSender.cs

@@ -0,0 +1,72 @@
+using System;
+using StatsdClient.Statistic;
+
+namespace StatsdClient.Bufferize
+{
+    /// <summary>
+    /// SynchronousSender sends metrics synchronously on the calling thread.
+    /// This is intended for serverless environments (e.g., AWS Lambda) where
+    /// background threads may be frozen between invocations.
+    /// </summary>
+    internal class SynchronousSender : IStatsBufferize
+    {
+        [ThreadStatic]
+        private static Stats _threadLocalStats;
+
+        private readonly StatsRouter _statsRouter;
+        private readonly Action<Exception> _optionalExceptionHandler;
+        private readonly object _lock = new object();
+
+        public SynchronousSender(StatsRouter statsRouter, Action<Exception> optionalExceptionHandler = null)
+        {
+            _statsRouter = statsRouter ?? throw new ArgumentNullException(nameof(statsRouter));
+            _optionalExceptionHandler = optionalExceptionHandler;
+        }
+
+        public bool TryDequeueFromPool(out Stats stats)
+        {
+            if (_threadLocalStats == null)
+            {
+                _threadLocalStats = new Stats();
+            }
+
+            stats = _threadLocalStats;
+            return true;
+        }
+
+        public void Send(Stats stats)
+        {
+            try
+            {
+                lock (_lock)
+                {
+                    _statsRouter.Route(stats);
+                }
+            }
+            catch (Exception e)
+            {
+                _optionalExceptionHandler?.Invoke(e);
+            }
+        }
+
+        public void Flush()
+        {
+            try
+            {
+                lock (_lock)
+                {
+                    _statsRouter.Flush();
+                }
+            }
+            catch (Exception e)
+            {
+                _optionalExceptionHandler?.Invoke(e);
+            }
+        }
+
+        public void Dispose()
+        {
+            Flush();
+        }
+    }
+}

src/StatsdClient/MetricsSender.cs

@@ -7,14 +7,14 @@ namespace StatsdClient
     internal class MetricsSender
     {
         private readonly Telemetry _optionalTelemetry;
-        private readonly StatsBufferize _statsBufferize;
+        private readonly IStatsBufferize _statsBufferize;
         private readonly bool _truncateIfTooLong;
         private readonly IStopWatchFactory _stopwatchFactory;
         private readonly IRandomGenerator _randomGenerator;
         private readonly Cardinality? _defaultCardinality;
 
         internal MetricsSender(
-                    StatsBufferize statsBufferize,
+                    IStatsBufferize statsBufferize,
                     IRandomGenerator randomGenerator,
                     IStopWatchFactory stopwatchFactory,
                     Telemetry optionalTelemetry,

src/StatsdClient/StatsdBuilder.cs

@@ -32,14 +32,15 @@ public StatsdData BuildStatsData(StatsdConfig config, Action<Exception> optional
 
             var originDetectionEnabled = IsOriginDetectionEnabled(config);
             var serializers = CreateSerializers(config.Prefix, globalTags, config.Advanced.MaxMetricsInAsyncQueue, originDetectionEnabled, config.ContainerID);
-            var telemetry = CreateTelemetry(serializers.MetricSerializer, config, globalTags, endPoint, transportData.Transport, optionalExceptionHandler);
+            var telemetry = CreateTelemetry(serializers.MetricSerializer, config, globalTags, endPoint, transportData.Transport, optionalExceptionHandler, config.SynchronousMode);
             var statsBufferize = CreateStatsBufferize(
                 telemetry,
                 transportData.Transport,
                 transportData.BufferCapacity,
                 config.Advanced,
                 serializers,
                 config.ClientSideAggregation,
+                config.SynchronousMode,
                 optionalExceptionHandler);
 
             var metricsSender = new MetricsSender(
@@ -179,7 +180,8 @@ private Telemetry CreateTelemetry(
             string[] globalTags,
             DogStatsdEndPoint dogStatsdEndPoint,
             ITransport transport,
-            Action<Exception> optionalExceptionHandler)
+            Action<Exception> optionalExceptionHandler,
+            bool synchronousMode = false)
         {
             var telemetryFlush = config.Advanced.TelemetryFlushInterval;
 
@@ -194,7 +196,7 @@ private Telemetry CreateTelemetry(
                     telemetryTransport = CreateTransport(optionalTelemetryEndPoint, config);
                 }
 
-                return _factory.CreateTelemetry(metricSerializer, version, telemetryFlush.Value, telemetryTransport, globalTags, optionalExceptionHandler);
+                return _factory.CreateTelemetry(metricSerializer, version, telemetryFlush.Value, telemetryTransport, globalTags, optionalExceptionHandler, synchronousMode);
             }
 
             // Telemetry is not enabled
@@ -244,13 +246,14 @@ private TransportData CreateTransportData(DogStatsdEndPoint endPoint, StatsdConf
             return transportData;
         }
 
-        private StatsBufferize CreateStatsBufferize(
+        private IStatsBufferize CreateStatsBufferize(
             Telemetry telemetry,
             ITransport transport,
             int bufferCapacity,
             AdvancedStatsConfig config,
             Serializers serializers,
             ClientSideAggregationConfig optionalClientSideAggregationConfig,
+            bool synchronousMode,
             Action<Exception> optionalExceptionHandler)
         {
             var bufferHandler = new BufferBuilderHandler(telemetry, transport);
@@ -276,14 +279,17 @@ private StatsBufferize CreateStatsBufferize(
 
             var statsRouter = _factory.CreateStatsRouter(serializers, bufferBuilder, optionalAggregators);
 
-            var statsBufferize = _factory.CreateStatsBufferize(
+            if (synchronousMode)
+            {
+                return new SynchronousSender(statsRouter, optionalExceptionHandler);
+            }
+
+            return _factory.CreateStatsBufferize(
                 statsRouter,
                 config.MaxMetricsInAsyncQueue,
                 config.MaxBlockDuration,
                 config.DurationBeforeSendingNotFullBuffer,
                 optionalExceptionHandler);
-
-            return statsBufferize;
         }
 
         private ITransport CreateUDPTransport(DogStatsdEndPoint endPoint)

src/StatsdClient/StatsdConfig.cs

@@ -160,5 +160,15 @@ public StatsdConfig()
         /// This value is used when no cardinality is explicitly specified.
         /// </summary>
         public Cardinality? Cardinality { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the client operates in synchronous mode.
+        /// When enabled, metrics are sent directly on the calling thread without background
+        /// processing. This is recommended for serverless environments (e.g., AWS Lambda)
+        /// where background threads may be frozen between invocations.
+        /// Call Flush() at the end of each invocation to ensure all buffered metrics are sent.
+        /// Default is false.
+        /// </summary>
+        public bool SynchronousMode { get; set; } = false;
     }
 }

src/StatsdClient/StatsdData.cs

@@ -7,11 +7,11 @@ namespace StatsdClient
     internal class StatsdData : IDisposable
     {
         private ITransport _transport;
-        private StatsBufferize _statsBufferize;
+        private IStatsBufferize _statsBufferize;
 
         public StatsdData(
             MetricsSender metricsSender,
-            StatsBufferize statsBufferize,
+            IStatsBufferize statsBufferize,
             ITransport transport,
             Telemetry telemetry)
         {

src/StatsdClient/Telemetry.cs

@@ -40,7 +40,8 @@ public Telemetry(
             TimeSpan flushInterval,
             ITransport transport,
             string[] globalTags,
-            Action<Exception> optionalExceptionHandler)
+            Action<Exception> optionalExceptionHandler,
+            bool synchronousMode = false)
         {
             _optionalMetricSerializer = metricSerializer;
             _optionalTransport = transport;
@@ -53,11 +54,14 @@ public Telemetry(
             _aggregatedContexts.Add(MetricType.Count, new ValueWithTags(_optionalTags, "metrics_type:count"));
             _aggregatedContexts.Add(MetricType.Set, new ValueWithTags(_optionalTags, "metrics_type:set"));
             _optionalExceptionHandler = optionalExceptionHandler;
-            _optionalTimer = new Timer(
-                _ => Flush(),
-                null,
-                flushInterval,
-                flushInterval);
+            if (!synchronousMode)
+            {
+                _optionalTimer = new Timer(
+                    _ => Flush(),
+                    null,
+                    flushInterval,
+                    flushInterval);
+            }
         }
 
         public static string MetricsMetricName => _telemetryPrefix + "metrics";