logstash-input-azureblob 0.9.12-java

data/logstash-input-azureblob.gemspec

@@ -0,0 +1,32 @@
+Gem::Specification.new do |s|
+  s.name          = 'logstash-input-azureblob'
+  s.version       = '0.9.12'
+  s.platform      = "java"
+  s.licenses      = ['Apache License (2.0)']
+  s.summary       = 'This plugin collects Microsoft Azure Diagnostics data from Azure Storage Blobs.'
+  s.description   = 'This gem is a Logstash plugin. It reads and parses data from Azure Storage Blobs.'
+  s.homepage      = 'https://github.com/Azure/azure-diagnostics-tools'
+  s.authors       = ['Microsoft Corporation']
+  s.email         = 'azdiag@microsoft.com'
+  s.require_paths = ['lib']
+
+  # Files
+  s.files = Dir['lib/**/*','spec/**/*','vendor/**/*','*.gemspec','*.md','Gemfile','LICENSE']
+  # Tests
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+
+  # Special flag to let us know this is actually a logstash plugin
+  s.metadata = { "logstash_plugin" => "true", "logstash_group" => "input" }
+
+  # Gem dependencies
+  s.add_runtime_dependency "logstash-core-plugin-api", '>= 1.60', '<= 2.99'
+  s.add_runtime_dependency 'logstash-codec-json_lines'
+  s.add_runtime_dependency 'stud', '>= 0.0.22'
+  s.add_runtime_dependency 'azure-storage', '~> 0.12.3.preview'
+  s.add_development_dependency 'logstash-devutils'
+  s.add_development_dependency 'logging'
+
+  # Jar dependencies
+  s.requirements << "jar 'org.glassfish:javax.json', '1.1'"
+  s.add_runtime_dependency 'jar-dependencies'
+end

data/spec/com/microsoft/json-parser_spec.rb

@@ -0,0 +1,280 @@
+require "logstash/devutils/rspec/spec_helper"
+require "logging"
+require "com/microsoft/json-parser"
+
+describe JsonParser do
+    before(:each) do
+        @logger = Logging.logger(STDOUT)
+        @logger.level = :debug
+        @linear_reader = spy
+
+        @on_content = double
+        @on_error = double
+    end
+
+    def construct(json_str)
+        @linear_reader_index = 0
+        allow(@linear_reader).to receive(:read) do ->(){
+            start_index = @linear_reader_index
+            @linear_reader_index = @linear_reader_index + 42
+            return json_str[start_index..@linear_reader_index - 1], @linear_reader_index < json_str.length ? true : false
+        }.call
+        end
+        return JsonParser.new(@logger, @linear_reader)
+    end
+
+    it 'can parse a complete JSON' do
+        json_str = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        parser = construct(json_str)
+
+        expect(@on_error).to_not receive(:call)
+        expect(@on_content).to receive(:call).with(json_str).once
+
+        parser.parse(@on_content, @on_error)
+    end
+
+    it 'can parse multiple JSON objects' do
+        json_strings = [
+            "{\"entity\":{ \"number\":42, \"string\":\"some string\", \"val\":null }}",
+            "{\"entity2\":{ \"number2\":422, \"string2\":\"some string2\" }}",
+            "{\"entity3\":{ \"number3\":422, \"string3\":\"some string2\", \"array\":[{\"abc\":\"xyz\"}] }}",
+            "\n\r{\"entity4\":{ \"number4\":422, \"string4\":\"some string2\", \"empty_array\":[] }}",
+            "  {\"entity5\":{ \"number5\":422, \"string5\":\"some string2\" }}",
+            " {\"abc\" :\"xyz\"}"
+        ]
+        content = ""
+        json_strings.each do |str|
+            content << str
+            expect(@on_content).to receive(:call).with(str).ordered
+        end
+        expect(@on_error).to_not receive(:call)
+
+        parser = construct(content)
+
+        parser.parse(@on_content, @on_error)
+    end
+
+    it 'will ignore regular text' do
+        not_a_json = "not a json"
+        parser = construct(not_a_json)
+        skipped_bytes = 0
+        expect(@on_content).to_not receive(:call)
+
+        received_malformed_str = ""
+        allow(@on_error).to receive(:call) do |malformed_json|
+            received_malformed_str << malformed_json
+        end
+
+        parser.parse(@on_content, @on_error)
+
+        expect(received_malformed_str).to eq(not_a_json)
+    end
+
+    it 'will ignore malformed JSON' do
+        not_a_json = "{\"entity\":{ \"number\":42, \"string\":\"comma is missing here ->\" \"<- here\":null }}"
+        parser = construct(not_a_json)
+        skipped_bytes = 0
+        expect(@on_content).to_not receive(:call)
+
+        received_malformed_str = ""
+        allow(@on_error).to receive(:call) do |malformed_json|
+            received_malformed_str << malformed_json
+        end
+
+        parser.parse(@on_content, @on_error)
+
+        expect(received_malformed_str).to eq(not_a_json)
+    end
+
+    it 'will skip comma between JSONs' do
+        json_str = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        not_a_json = ","
+        parser = construct(json_str+not_a_json+json_str)
+
+        expect(@on_content).to receive(:call).with(json_str).once.ordered
+        expect(@on_error).to receive(:call).with(",").once.ordered
+        expect(@on_content).to receive(:call).with(json_str).once.ordered
+
+        parser.parse(@on_content, @on_error)
+    end
+
+    it 'will skip regular text in the middle' do
+        json_str = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        not_a_json = "not a json"
+        parser = construct(json_str+not_a_json+json_str)
+
+        expect(@on_content).to receive(:call).with(json_str).once.ordered
+        expect(@on_content).to receive(:call).with(json_str).once.ordered
+
+        received_malformed_str = ""
+        allow(@on_error).to receive(:call) do |malformed_json|
+            received_malformed_str << malformed_json
+        end
+
+        parser.parse(@on_content, @on_error)
+
+        expect(received_malformed_str).to eq(not_a_json)
+    end
+
+    it 'can parse multiple JSON objects in between malformed content' do
+        strings = [
+            [ true, "{\"entity\":{ \"number\":42, \"string\":\"some string\", \"val\":null }}"],
+            [ true, "{\"entity2\":{ \"number2\":422, \"string2\":\"some string2\" }}"],
+            [ false, ","],
+            [ true, "{\"entity3\":{ \"number3\":422, \"string3\":\"some string2\", \"array\":[{\"abc\":\"xyz\"}] }}"],
+            [ false, "some random text \n\r"],
+            [ true, "{\"entity4\":{ \"number4\":422, \"string4\":\"some string2\", \"empty_array\":[] }}"],
+            [ false, "{\"entity\":{ \"number\":42, \"string\":\"some string\" \"val\":null }}  "],
+            [ true, "{\"entity5\":{ \"number5\":422, \"string5\":\"some string2\" }}"],
+            [ true, " {\"abc\" :\"xyz\"}"]
+        ]
+        content = ""
+        strings.each do |is_valid_json, str|
+            content << str
+            if is_valid_json
+                expect(@on_content).to receive(:call).with(str).ordered
+            else
+            end
+        end
+        allow(@on_error).to receive(:call)
+
+        parser = construct(content)
+
+        parser.parse(@on_content, @on_error)
+    end
+
+    it 'will batch together malformed content in a single callback' do
+        strings = [
+            [ true, "{\"entity\":{ \"number\":42, \"string\":\"some string\", \"val\":null }}"],
+            [ true, "{\"entity2\":{ \"number2\":422, \"string2\":\"some string2\" }}"],
+            [ false, ","],
+            [ true, "{\"entity3\":{ \"number3\":422, \"string3\":\"some string2\", \"array\":[{\"abc\":\"xyz\"}] }}"],
+            [ false, "some random text \n\r"], #whitespace after malformed data will be part of the malformed string
+            [ true, "{\"entity4\":{ \"number4\":422, \"string4\":\"some string2\", \"empty_array\":[] }}"],
+            [ false, "{\"entity\":{ \"number\":42, \"string\":\"some string\" \"val\":null }}  "],
+            [ true, "{\"entity5\":{ \"number5\":422, \"string5\":\"some string2\" }}"],
+            [ true, "\n\r {\"abc\" :\"xyz\"}"] # whitespace after correct jsons will be part of the next json
+        ]
+        content = ""
+        strings.each do |is_valid_json, str|
+            content << str
+            if is_valid_json
+                expect(@on_content).to receive(:call).with(str).ordered
+            else
+                expect(@on_error).to receive(:call).with(str).ordered
+            end
+        end
+
+        parser = construct(content)
+
+        parser.parse(@on_content, @on_error)
+    end
+end
+
+describe StreamReader do
+    before(:each) do
+        @logger = Logging.logger(STDOUT)
+        @logger.level = :debug
+
+        @linear_reader = double
+        @stream_reader = StreamReader.new(@logger, @linear_reader)
+    end
+
+    it 'does not support mark' do
+        expect(@stream_reader.markSupported).to eq(false)
+    end
+
+    it 'can read full stream' do
+        full_content = "entire content"
+        input_buffer = Java::char[full_content.length].new
+
+        expect(@linear_reader).to receive(:read).and_return([full_content, false]).once
+
+        @stream_reader.read(input_buffer, 0, full_content.length)
+
+        expect(java::lang::String.new(input_buffer)).to eq(full_content)
+    end
+
+    it 'reads until requested buffer is filled' do
+        full_content = "entire content"
+        input_buffer = Java::char[full_content.length].new
+
+        expect(@linear_reader).to receive(:read).twice.and_return([full_content[0..full_content.length/2], true],[full_content[full_content.length/2 + 1..-1], true])
+
+        @stream_reader.read(input_buffer, 0, full_content.length)
+
+        expect(java::lang::String.new(input_buffer)).to eq(full_content)
+    end
+
+    it 'does not call the read callback when buffer length is 0' do
+        expect(@linear_reader).to_not receive(:read)
+
+        @stream_reader.read(nil, 0, 0)
+    end
+
+    it 'caches if it reads ahead' do
+        full_content = "entire content"
+        input_buffer = Java::char[full_content.length].new
+
+        expect(@linear_reader).to receive(:read).and_return([full_content, false]).once
+
+        (0..full_content.length - 1).each do |i|
+            @stream_reader.read(input_buffer, i, 1)
+        end
+        
+        expect(java::lang::String.new(input_buffer)).to eq(full_content)
+    end
+
+    it 'returns -1 when read callback returns empty and there are no more bytes' do
+        expect(@linear_reader).to receive(:read).and_return(["", false]).once
+
+        expect(@stream_reader.read(nil, 0, 42)).to eq(-1)
+    end
+
+    it 'will store stream buffer' do
+        full_content = "entire content"
+        bytes_to_read = 4
+        input_buffer = Java::char[bytes_to_read].new
+
+        expect(@linear_reader).to receive(:read).and_return([full_content, false]).once
+
+        @stream_reader.read(input_buffer, 0, bytes_to_read)
+
+        expect(@stream_reader.get_cached_stream_length).to eq(full_content.length)
+        expect(@stream_reader.get_cached_stream_index).to eq(bytes_to_read)
+        expect(@stream_reader.get_stream_buffer(0,-1)).to eq(full_content)
+    end
+
+    it 'will do nothing when drop_stream is called but the until_offset is greater than stream index' do
+        full_content = "entire content"
+        bytes_to_read = 4
+        input_buffer = Java::char[bytes_to_read].new
+
+        expect(@linear_reader).to receive(:read).and_return([full_content, false]).once
+
+        @stream_reader.read(input_buffer, 0, bytes_to_read)
+
+        @stream_reader.drop_stream(@stream_reader.get_cached_stream_index + 1)
+
+        expect(@stream_reader.get_cached_stream_length).to eq(full_content.length)
+        expect(@stream_reader.get_cached_stream_index).to eq(bytes_to_read)
+        expect(@stream_reader.get_stream_buffer(0,-1)).to eq(full_content)
+    end
+
+    it 'will trim buffer stream when drop_stream is called' do
+        full_content = "entire content"
+        bytes_to_read = 4
+        until_offset = bytes_to_read - 2
+        input_buffer = Java::char[bytes_to_read].new
+
+        expect(@linear_reader).to receive(:read).and_return([full_content, false]).once
+
+        @stream_reader.read(input_buffer, 0, bytes_to_read)
+
+        @stream_reader.drop_stream(until_offset)
+
+        expect(@stream_reader.get_cached_stream_length).to eq(full_content.length - until_offset)
+        expect(@stream_reader.get_cached_stream_index).to eq(bytes_to_read - until_offset)
+        expect(@stream_reader.get_stream_buffer(0,-1)).to eq(full_content[until_offset..-1])
+    end
+end

data/spec/inputs/azureblob_spec.rb

@@ -0,0 +1,324 @@
+require "logstash/devutils/rspec/spec_helper"
+require "logging"
+require "logstash/inputs/azureblob"
+
+class LogStash::Codecs::JSON
+end
+
+describe LogStash::Inputs::LogstashInputAzureblob do
+
+    before(:each) do
+        @logger = Logging.logger(STDOUT)
+        @logger.level = :debug
+
+        @azure_blob_sdk = double
+        @json_codec = double("LogStash::Codecs::JSON", :is_a? => true)
+        @other_codec = double("other codec", :is_a? => false)
+
+        @azureblob_input = LogStash::Inputs::LogstashInputAzureblob.new
+        @azureblob_input.instance_variable_set(:@logger, @logger)
+        @azureblob_input.instance_variable_set(:@file_head_bytes, 0)
+        @azureblob_input.instance_variable_set(:@file_tail_bytes, 0)
+        @azureblob_input.instance_variable_set(:@azure_blob, @azure_blob_sdk)
+        @azureblob_input.instance_variable_set(:@container, double)
+        @azureblob_input.instance_variable_set(:@codec, @other_codec)
+        allow(@azureblob_input).to receive(:update_registry)
+    end
+
+    def set_json_codec
+        @azureblob_input.instance_variable_set(:@codec, @json_codec)
+    end
+
+    def stub_blob(blob_name, content)
+        allow(@azure_blob_sdk).to receive(:get_blob).with(anything(), blob_name, anything()) do |container,  blob_name_arg, props | 
+            ->(){
+                start_index = 0
+                end_index = -1
+                start_index = props[:start_range] unless props[:start_range].nil?
+                end_index = props[:end_range] unless props[:end_range].nil?
+
+                ret_str = content[start_index..end_index]
+                @logger.debug("get_blob(#{start_index},#{end_index}): |#{ret_str}|")
+                return double, ret_str
+            }.call
+        end
+
+        return double(:name => blob_name, :properties => { 
+            :content_length => content.length,
+            :etag => nil
+        })
+    end
+
+    it "can parse basic JSON" do
+        blob_name = "basic_json"
+        json_str = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        set_json_codec()
+
+        blob = stub_blob(blob_name, json_str)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+
+        expect(@json_codec).to receive(:decode).with(json_str).ordered
+        expect(@json_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "can parse multiple JSONs" do
+        blob_name = "multi_json"
+        json_str1 = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        json_str2 = "{\"entity2\":{ \"number2\":422, \"string2\":\"some other string\" }}"
+        json_str3 = " \n{\"entity3\":{ \"number2\":422, \"string2\":\"some other string\" }}"
+        set_json_codec()
+
+        blob = stub_blob(blob_name, json_str1 + json_str2 + json_str3)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+
+        expect(@json_codec).to receive(:decode).with(json_str1).once.ordered
+        expect(@json_codec).to receive(:decode).with(json_str2).once.ordered
+        expect(@json_codec).to receive(:decode).with(json_str3).once.ordered
+        expect(@json_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will parse JSONs from blob start" do
+        blob_name = "non_zero_json_start"
+        json_str1 = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        json_str2 = "{\"entity2\":{ \"number2\":422, \"string2\":\"some other string\" }}"
+        set_json_codec()
+
+        blob = stub_blob(blob_name, json_str1 + json_str2)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, json_str1.length, nil])
+
+        expect(@json_codec).to receive(:decode).with(json_str2).once.ordered
+        expect(@json_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "can parse out malformed JSONs" do
+        blob_name = "parse_out_malformed"
+        json_str1 = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        json_str2 = "{\"entity2\":{ \"number2\":422, \"string2\":\"some other string\" }}"
+        malformed_data = [",", "asdgasfgasfg", "{\"entity\"", "}", "{\"broken_json\":{\"a\":2 \"b\":3}}"]
+        set_json_codec()
+
+        malformed_data.each do |malformed|
+            blob = stub_blob(blob_name, json_str1 + malformed + json_str2)
+
+            allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+
+            expect(@json_codec).to receive(:decode).with(json_str1).once.ordered
+            expect(@json_codec).to receive(:decode).with(json_str2).once.ordered
+
+            @azureblob_input.process(nil)
+        end
+    end
+
+    it "can build JSONs with header and tail" do
+        blob_name = "head_tail_json"
+        json_str1 = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}"
+        json_str2 = "{\"entity2\":{ \"number2\":422, \"string2\":\"some other string\" }}"
+        already_parsed = "{\"parsed_json\":true}"
+        head = "{\"xyz\":42}{\"entities\" : \n["
+        tail = "\n] }{\"abc\":42}\n"
+        set_json_codec()
+        @azureblob_input.instance_variable_set(:@file_head_bytes, head.length)
+        @azureblob_input.instance_variable_set(:@file_tail_bytes, tail.length)
+
+        blob = stub_blob(blob_name, head + already_parsed + json_str1 + json_str2 + tail)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, (head + already_parsed).length, nil])
+
+        expect(@json_codec).to receive(:decode).with(head + json_str1 + tail).once.ordered
+        expect(@json_codec).to receive(:decode).with(head + json_str2 + tail).once.ordered
+        expect(@json_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will update the registry offset when parsing JSON" do
+        blob_name = "json_end_index"
+        content = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }},{},{\"a\":2} random text at the end"
+        set_json_codec()
+
+        blob = stub_blob(blob_name, content)
+
+        registry_file_path = ""
+        registry_offset = -1
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+        allow(@json_codec).to receive(:decode).and_return([])
+
+        expect(@azureblob_input).to receive(:update_registry) do |new_registry_item|
+            registry_file_path = new_registry_item.file_path
+            registry_offset = new_registry_item.offset
+        end
+
+        @azureblob_input.process(nil)
+
+        expect(registry_file_path).to eq(blob_name)
+        expect(registry_offset).to eq(content.length)
+    end
+
+    it "can output simple text" do
+        blob_name = "basic_content"
+        content = "some text\nmore text"
+
+        blob = stub_blob(blob_name, content)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+
+        expect(@other_codec).to receive(:decode).with(content).ordered
+        expect(@other_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will add header and tail when the codec is not json" do
+        blob_name = "head_tail_non_json"
+        content = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}\n{\"entity2\":{ \"number2\":422, \"string2\":\"some other string\" }}"
+        already_parsed = "{\"parsed_json\":true}"
+        head = "{\"xyz\":42}{\"entities\" : \n["
+        tail = "\n] }{\"abc\":42}\n"
+
+        @azureblob_input.instance_variable_set(:@file_head_bytes, head.length)
+        @azureblob_input.instance_variable_set(:@file_tail_bytes, tail.length)
+
+        blob = stub_blob(blob_name, head + already_parsed + content + tail)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, (head + already_parsed).length, nil])
+
+        expect(@other_codec).to receive(:decode).with(head + content + tail).once.ordered
+        expect(@other_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will output content in chunks when the codec is not json" do
+        blob_name = "chunked_content"
+        #same size chunks
+        chunk1 = "first chunk \n|"
+        chunk2 = "second chunk \n"
+        chunk3 = "third chunk \n|"
+        smaller_chunk = "smaller\n"
+        content = chunk1 + chunk2 + chunk3 + smaller_chunk
+
+        blob = stub_blob(blob_name, content) 
+        @azureblob_input.instance_variable_set(:@file_chunk_size_bytes, chunk1.length)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+
+        expect(@other_codec).to receive(:decode).with(chunk1).once.ordered
+        expect(@other_codec).to receive(:decode).with(chunk2).once.ordered
+        expect(@other_codec).to receive(:decode).with(chunk3).once.ordered
+        expect(@other_codec).to receive(:decode).with(smaller_chunk).once.ordered
+        expect(@other_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will start from offset index when the codec is not json" do
+        blob_name = "skip_start_index"
+        already_parsed = "===="
+        actual_content = "some text\nmore text"
+
+        blob = stub_blob(blob_name,  already_parsed + actual_content)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, already_parsed.length, nil])
+
+        expect(@other_codec).to receive(:decode).with(actual_content).ordered
+        expect(@other_codec).to_not receive(:decode).ordered
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will update the registry offset when the codec is not json" do
+        blob_name = "non_json_end_index"
+        content = "{\"entity\":{ \"number\":42, \"string\":\"some string\" }},{},{\"a\":2} random text at the end"
+
+        blob = stub_blob(blob_name, content)
+
+        registry_file_path = ""
+        registry_offset = -1
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+        allow(@other_codec).to receive(:decode).and_return([])
+
+        expect(@azureblob_input).to receive(:update_registry) do |new_registry_item|
+            registry_file_path = new_registry_item.file_path
+            registry_offset = new_registry_item.offset
+        end
+
+        @azureblob_input.process(nil)
+
+        expect(registry_file_path).to eq(blob_name)
+        expect(registry_offset).to eq(content.length)
+    end
+
+    it "will update registry after n entries" do
+        chunk_size = 5
+        update_count = 3
+        blob_name = "force_registry_offset"
+        entries = [
+            "first chunk \n",
+            "second chunk",
+            "third",
+            "dgsdfgfgfg",
+            "132435436",
+            "dgsdfgfgfg"
+        ]
+        stub_const("LogStash::Inputs::LogstashInputAzureblob::UPDATE_REGISTRY_COUNT", update_count)
+
+        content = ""
+        entries.each do |entry|
+            content << entry[0..chunk_size]
+        end
+
+        blob = stub_blob(blob_name, content)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+        @azureblob_input.instance_variable_set(:@file_chunk_size_bytes, chunk_size)
+        allow(@other_codec).to receive(:decode).and_return([])
+
+        update_registry_count = entries.length / update_count + 1
+        expect(@azureblob_input).to receive(:update_registry).exactly(update_registry_count).times
+
+        @azureblob_input.process(nil)
+    end
+
+    it "will update registry after n entries when the codec is json" do
+        chunk_size = 5
+        update_count = 3
+        blob_name = "force_registry_offset_json"
+        entries = [
+            "{\"entity\":{ \"number\":42, \"string\":\"some string\" }}\n{\"entity2\":{ \"number2\":422, \"string2\":\"some other string\" }}",
+            "invalid",
+            "{\"val\":42}\n ",
+            "{}",
+            "{\"val}",
+            "dgsdfgfgfg"
+        ]
+        set_json_codec()
+        stub_const("LogStash::Inputs::LogstashInputAzureblob::UPDATE_REGISTRY_COUNT", update_count)
+
+        content = ""
+        entries.each do |entry|
+            content << entry
+        end
+
+        blob = stub_blob(blob_name, content)
+
+        allow(@azureblob_input).to receive(:register_for_read).and_return([blob, 0, nil])
+        allow(@json_codec).to receive(:decode).and_return([])
+
+        update_registry_count = entries.length / update_count + 1
+        expect(@azureblob_input).to receive(:update_registry).exactly(update_registry_count).times
+
+        @azureblob_input.process(nil)
+    end
+
+end