diff --git a/level_zero/tools/source/metrics/metric_oa_streamer_imp.cpp b/level_zero/tools/source/metrics/metric_oa_streamer_imp.cpp
index 55811376d2..af4b9a388d 100644
--- a/level_zero/tools/source/metrics/metric_oa_streamer_imp.cpp
+++ b/level_zero/tools/source/metrics/metric_oa_streamer_imp.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -88,6 +88,8 @@ ze_result_t OaMetricStreamerImp::readData(uint32_t maxReportCount, size_t *pRawD
         result = metricGroup->readIoStream(reportCount, *pRawData);
         if (result == ZE_RESULT_SUCCESS || result == ZE_RESULT_WARNING_DROPPED_DATA) {
             *pRawDataSize = reportCount * rawReportSize;
+        } else {
+            *pRawDataSize = 0;
         }
     }
 
diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_collector.cpp b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_collector.cpp
index 22cf73531d..f8049a015c 100644
--- a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_collector.cpp
+++ b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_collector.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -113,6 +113,8 @@ void SingleMetricStreamerCollector::showResults() {
         zmu::sleep(5);
         VALIDATECALL(zetMetricStreamerReadData(metricStreamer, maxRawReportCount, &rawDataSize, rawData.data()));
         LOG(zmu::LogLevel::DEBUG) << "Streamer read raw bytes: " << rawDataSize << std::endl;
+    } else if (status != ZE_RESULT_SUCCESS) {
+        LOG(zmu::LogLevel::DEBUG) << "zetMetricStreamerReadData() returned Error status with code: " << status << std::endl;
     }
     zmu::obtainCalculatedMetrics(metricGroup, rawData.data(), static_cast<uint32_t>(rawDataSize));
 }
diff --git a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_tests.cpp b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_tests.cpp
index 066fbd03d4..556ed4be19 100644
--- a/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_tests.cpp
+++ b/level_zero/tools/test/black_box_tests/zello_metrics/zello_metrics_tests.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -95,10 +95,12 @@ bool streamTest() {
             std::make_unique<SingleDeviceSingleQueueExecutionCtxt>(deviceId, subDeviceId);
         executionCtxt->setExecutionTimeInMilliseconds(200);
 
-        std::unique_ptr<Power> power = std::make_unique<Power>(executionCtxt->getDeviceHandle(0));
-        std::unique_ptr<Frequency> frequency = std::make_unique<Frequency>(executionCtxt->getDeviceHandle(0));
+        std::unique_ptr<Power> power;
+        std::unique_ptr<Frequency> frequency;
 
         if (testSettings->showSystemInfo.get()) {
+            power = std::make_unique<Power>(executionCtxt->getDeviceHandle(0));
+            frequency = std::make_unique<Frequency>(executionCtxt->getDeviceHandle(0));
             executionCtxt->addSystemParameterCapture(power.get());
             executionCtxt->addSystemParameterCapture(frequency.get());
         }
diff --git a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp
index 5961f76205..0bd466adec 100644
--- a/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp
+++ b/level_zero/tools/test/unit_tests/sources/metrics/test_metric_oa_streamer_1.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2024 Intel Corporation
+ * Copyright (C) 2020-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -977,6 +977,113 @@ TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCal
     EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
 }
 
+TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCalledAndReadIoStreamFailsThenErrorUnknownIsReturnedAndRawDataSizeIsZero) {
+
+    // One api: device handle.
+    zet_device_handle_t metricDeviceHandle = device->toHandle();
+
+    // One api: event handle.
+    ze_event_handle_t eventHandle = {};
+
+    // One api: streamer handle.
+    zet_metric_streamer_handle_t streamerHandle = {};
+    zet_metric_streamer_desc_t streamerDesc = {};
+
+    streamerDesc.stype = ZET_STRUCTURE_TYPE_METRIC_STREAMER_DESC;
+    streamerDesc.notifyEveryNReports = 32768;
+    streamerDesc.samplingPeriod = 1000;
+
+    // One api: metric group handle.
+    auto &metricOaSource = (static_cast<DeviceImp *>(device))->getMetricDeviceContext().getMetricSource<OaMetricSourceImp>();
+    Mock<MetricGroup> metricGroup(metricOaSource);
+    zet_metric_group_handle_t metricGroupHandle = metricGroup.toHandle();
+    zet_metric_group_properties_t metricGroupProperties = {ZET_STRUCTURE_TYPE_METRIC_GROUP_PROPERTIES, nullptr};
+
+    // Metrics Discovery device.
+    metricsDeviceParams.ConcurrentGroupsCount = 1;
+
+    // Metrics Discovery concurrent group.
+    Mock<IConcurrentGroup_1_13> metricsConcurrentGroup;
+    TConcurrentGroupParams_1_13 metricsConcurrentGroupParams = {};
+    metricsConcurrentGroupParams.MetricSetsCount = 1;
+    metricsConcurrentGroupParams.SymbolName = "OA";
+    metricsConcurrentGroupParams.Description = "OA description";
+    metricsConcurrentGroupParams.IoMeasurementInformationCount = 1;
+
+    Mock<MetricsDiscovery::IEquation_1_0> ioReadEquation;
+    MetricsDiscovery::TEquationElement_1_0 ioEquationElement = {};
+    ioEquationElement.Type = MetricsDiscovery::EQUATION_ELEM_IMM_UINT64;
+    ioEquationElement.ImmediateUInt64 = 1;
+
+    ioReadEquation.getEquationElement.push_back(&ioEquationElement);
+
+    Mock<MetricsDiscovery::IInformation_1_0> ioMeasurement;
+    MetricsDiscovery::TInformationParams_1_0 oaInformation = {};
+    oaInformation.SymbolName = "BufferOverflow";
+    oaInformation.IoReadEquation = &ioReadEquation;
+    ioMeasurement.GetParamsResult = &oaInformation;
+
+    // Metrics Discovery metric set.
+    Mock<MetricsDiscovery::IMetricSet_1_13> metricsSet;
+    MetricsDiscovery::TMetricSetParams_1_11 metricsSetParams = {};
+    metricsSetParams.ApiMask = MetricsDiscovery::API_TYPE_IOSTREAM;
+    metricsSetParams.MetricsCount = 0;
+    metricsSetParams.SymbolName = "Metric set name";
+    metricsSetParams.ShortName = "Metric set description";
+    metricsSetParams.RawReportSize = 256;
+
+    openMetricsAdapter();
+    setupDefaultMocksForMetricDevice(metricsDevice);
+
+    metricsDevice.getConcurrentGroupResults.push_back(&metricsConcurrentGroup);
+
+    metricsConcurrentGroup.GetParamsResult = &metricsConcurrentGroupParams;
+    metricsConcurrentGroup.getMetricSetResult = &metricsSet;
+    metricsSet.GetParamsResult = &metricsSetParams;
+    metricsConcurrentGroup.GetIoMeasurementInformationResult = &ioMeasurement;
+    metricsConcurrentGroup.readIoStreamResult = TCompletionCode::CC_ERROR_GENERAL;
+
+    // Metric group count.
+    uint32_t metricGroupCount = 0;
+    EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, nullptr), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+
+    // Metric group handle.
+    EXPECT_EQ(zetMetricGroupGet(metricDeviceHandle, &metricGroupCount, &metricGroupHandle), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupCount, 1u);
+    EXPECT_NE(metricGroupHandle, nullptr);
+
+    // Metric group properties.
+    EXPECT_EQ(zetMetricGroupGetProperties(metricGroupHandle, &metricGroupProperties), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(metricGroupProperties.domain, 0u);
+    EXPECT_EQ(metricGroupProperties.samplingType, ZET_METRIC_GROUP_SAMPLING_TYPE_FLAG_TIME_BASED);
+    EXPECT_EQ(metricGroupProperties.metricCount, metricsSetParams.MetricsCount);
+    EXPECT_EQ(strcmp(metricGroupProperties.description, metricsSetParams.ShortName), 0);
+    EXPECT_EQ(strcmp(metricGroupProperties.name, metricsSetParams.SymbolName), 0);
+
+    // Metric group activation.
+    EXPECT_EQ(zetContextActivateMetricGroups(context->toHandle(), metricDeviceHandle, 1, &metricGroupHandle), ZE_RESULT_SUCCESS);
+
+    // Metric streamer open.
+    EXPECT_EQ(zetMetricStreamerOpen(context->toHandle(), metricDeviceHandle, metricGroupHandle, &streamerDesc, eventHandle, &streamerHandle), ZE_RESULT_SUCCESS);
+    EXPECT_NE(streamerHandle, nullptr);
+
+    // Metric streamer: get desired raw data size.
+    size_t rawSize = 0;
+    uint32_t reportCount = 256;
+    EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, reportCount, &rawSize, nullptr), ZE_RESULT_SUCCESS);
+
+    // Metric streamer: read the data.
+    std::vector<uint8_t> rawData;
+    rawData.resize(rawSize);
+    EXPECT_EQ(zetMetricStreamerReadData(streamerHandle, reportCount, &rawSize, rawData.data()), ZE_RESULT_ERROR_UNKNOWN);
+    const size_t expectedZeroSize = 0;
+    EXPECT_EQ(rawSize, expectedZeroSize);
+
+    // Metric streamer close.
+    EXPECT_EQ(zetMetricStreamerClose(streamerHandle), ZE_RESULT_SUCCESS);
+}
+
 TEST_F(MetricStreamerTest, givenValidArgumentsWhenZetMetricStreamerReadDataIsCalledWithMaxReportCountOverTheSupportedThenReturnsSuccess) {
 
     zet_device_handle_t metricDeviceHandle = device->toHandle();