Enforce string-only values in raw mode (#1022)

When using `raw: true`, only String values are now accepted. Previously,
non-string values were silently converted via `to_s`, causing issues like
`nil` becoming `""` and integers losing their type information.

This matches the behavior of client-level `raw: true` mode (StringMarshaller)
and aligns with the expectation that raw mode means "pass-through, no magic".

Breaking change: `set(key, nil, raw: true)` and `set(key, 123, raw: true)`
now raise MarshalError. Use string values for counters: `set('counter', '0', raw: true)`.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: petergoldstein

CHANGELOG.md

@@ -17,6 +17,16 @@ Bug Fixes:
   - Detects correct pack format for time_t and suseconds_t on each platform
   - Fixes timeout issues on architectures with 64-bit time_t
 
+- Fix get_multi hanging with large key counts (#776, #941)
+  - Add interleaved read/write for pipelined gets to prevent socket buffer deadlock
+  - For batches over 10,000 keys per server, requests are now sent in chunks
+
+- **Breaking:** Enforce string-only values in raw mode (#1022)
+  - `set(key, nil, raw: true)` now raises `MarshalError` instead of storing `""`
+  - `set(key, 123, raw: true)` now raises `MarshalError` instead of storing `"123"`
+  - This matches the behavior of client-level `raw: true` mode
+  - To store counters, use string values: `set('counter', '0', raw: true)`
+
 4.2.0
 ==========
 

lib/dalli/protocol/value_serializer.rb

@@ -32,22 +32,8 @@ def initialize(protocol_options)
       end
 
       def store(value, req_options, bitflags)
-        if req_options
-          return [value.to_s, bitflags] if req_options[:raw]
-
-          # If the value is a simple string, going through serialization is costly
-          # for no benefit other than preserving encoding.
-          # Assuming most strings are either UTF-8 or BINARY we can just store
-          # that information in the bitflags.
-          if req_options[:string_fastpath] && value.instance_of?(String)
-            case value.encoding
-            when Encoding::BINARY
-              return [value, bitflags]
-            when Encoding::UTF_8
-              return [value, bitflags | FLAG_UTF8]
-            end
-          end
-        end
+        return store_raw(value, bitflags) if req_options&.dig(:raw)
+        return store_string_fastpath(value, bitflags) if use_string_fastpath?(value, req_options)
 
         [serialize_value(value), bitflags | FLAG_SERIALIZED]
       end
@@ -85,6 +71,30 @@ def serialize_value(value)
 
       private
 
+      def store_raw(value, bitflags)
+        unless value.is_a?(String)
+          raise Dalli::MarshalError, "Dalli raw mode requires string values, got: #{value.class}"
+        end
+
+        [value, bitflags]
+      end
+
+      # If the value is a simple string, going through serialization is costly
+      # for no benefit other than preserving encoding.
+      # Assuming most strings are either UTF-8 or BINARY we can just store
+      # that information in the bitflags.
+      def store_string_fastpath(value, bitflags)
+        case value.encoding
+        when Encoding::BINARY then [value, bitflags]
+        when Encoding::UTF_8 then [value, bitflags | FLAG_UTF8]
+        else [serialize_value(value), bitflags | FLAG_SERIALIZED]
+        end
+      end
+
+      def use_string_fastpath?(value, req_options)
+        req_options&.dig(:string_fastpath) && value.instance_of?(String)
+      end
+
       def warn_if_marshal_default(protocol_options)
         return if protocol_options.key?(:serializer)
         return if @@marshal_warning_logged

test/integration/test_operations.rb

@@ -55,6 +55,39 @@
         end
       end
 
+      describe 'raw mode validation' do
+        it 'raises MarshalError when setting nil with raw: true' do
+          memcached_persistent(p) do |dc|
+            error = assert_raises Dalli::MarshalError do
+              dc.set('rawkey', nil, 0, raw: true)
+            end
+
+            assert_match(/raw mode requires string values/, error.message)
+            assert_match(/NilClass/, error.message)
+          end
+        end
+
+        it 'raises MarshalError when setting non-string with raw: true' do
+          memcached_persistent(p) do |dc|
+            error = assert_raises Dalli::MarshalError do
+              dc.set('rawkey', 123, 0, raw: true)
+            end
+
+            assert_match(/raw mode requires string values/, error.message)
+            assert_match(/Integer/, error.message)
+          end
+        end
+
+        it 'allows setting strings with raw: true' do
+          memcached_persistent(p) do |dc|
+            dc.flush
+
+            assert op_addset_succeeds(dc.set('rawkey', 'string_value', 0, raw: true))
+            assert_equal 'string_value', dc.get('rawkey', raw: true)
+          end
+        end
+      end
+
       describe 'gat' do
         it 'returns the value and touches on a hit' do
           memcached_persistent(p) do |dc|
@@ -265,7 +298,7 @@
           memcached_persistent(p) do |client|
             client.flush
 
-            assert op_addset_succeeds(client.set('fakecounter', 0, 0, raw: true))
+            assert op_addset_succeeds(client.set('fakecounter', '0', 0, raw: true))
             assert_equal 1, client.incr('fakecounter', 1)
             assert_equal 2, client.incr('fakecounter', 1)
             assert_equal 3, client.incr('fakecounter', 1)

test/integration/test_quiet.rb

@@ -158,7 +158,7 @@
           dc.close
           dc.flush
           key = SecureRandom.hex(3)
-          value = 546
+          value = '546'
           incr = 134
           dc.set(key, value, 90, raw: true)
 
@@ -181,7 +181,7 @@
           dc.close
           dc.flush
           key = SecureRandom.hex(3)
-          value = 546
+          value = '546'
           incr = 134
           dc.set(key, value, 90, raw: true)
 

test/protocol/test_value_serializer.rb

@@ -146,12 +146,49 @@
     describe 'when the request options value for the :raw key is true' do
       let(:req_options) { { raw: true } }
 
-      it 'does not call the serializer and just converts the input value to a string' do
-        val, newbitflags = vs.store(raw_value, req_options, bitflags)
+      describe 'with a string value' do
+        let(:string_value) { 'test string value' }
 
-        assert_equal val, raw_value.to_s
-        assert_equal newbitflags, bitflags
-        serializer.verify
+        it 'returns the string without serialization' do
+          val, newbitflags = vs.store(string_value, req_options, bitflags)
+
+          assert_equal string_value, val
+          assert_equal bitflags, newbitflags
+          serializer.verify
+        end
+      end
+
+      describe 'with a nil value' do
+        it 'raises MarshalError' do
+          error = assert_raises Dalli::MarshalError do
+            vs.store(nil, req_options, bitflags)
+          end
+
+          assert_match(/raw mode requires string values/, error.message)
+          assert_match(/NilClass/, error.message)
+        end
+      end
+
+      describe 'with a non-string value' do
+        it 'raises MarshalError' do
+          error = assert_raises Dalli::MarshalError do
+            vs.store(raw_value, req_options, bitflags)
+          end
+
+          assert_match(/raw mode requires string values/, error.message)
+          assert_match(/Object/, error.message)
+        end
+      end
+
+      describe 'with an integer value' do
+        it 'raises MarshalError' do
+          error = assert_raises Dalli::MarshalError do
+            vs.store(123, req_options, bitflags)
+          end
+
+          assert_match(/raw mode requires string values/, error.message)
+          assert_match(/Integer/, error.message)
+        end
       end
     end