2410916884

Committed 26 Mar 2026 01:11PM UTC coverage: 81.405% (-0.3%) from 81.686%

Build # 2410916884

Build Type

push

gitlab-ci

Committed by

vpodzime

Commit Message

feat: Large deployment logs are now trimmed to be accepted by the server

Deployment logs larger than 1 MiB are rejected by the
server which leads to two issues:

- excessive bandwith consumption when uploading such large logs
  only to be thrown away, and

- no deployment logs for particular device and particular failed
  deployment available at the server at all.

To prevent this, the client now trims large deployment logs and
only sends the biggest possible part of the logs from their end.

Ticket: MEN-9415
Changelog: title
Signed-off-by: Vratislav Podzimek <vratislav.podzimek+auto-signed@northern.tech>

Run Details

21 of 59 new or added lines in 2 files covered. (35.59%)

2 existing lines in 2 files now uncovered.

9027 of 11089 relevant lines covered (81.4%)

19799.17 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

63.64

/src/common/processes/processes.cpp

// Copyright 2023 Northern.tech AS
//
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.

#include <common/processes.hpp>

#include <common/log.hpp>
#include <common/common.hpp>

namespace mender {
namespace common {
namespace processes {

namespace log = mender::common::log;

const chrono::seconds DEFAULT_GENERATE_LINE_DATA_TIMEOUT {10};

const ProcessesErrorCategoryClass ProcessesErrorCategory;

const char *ProcessesErrorCategoryClass::name() const noexcept {
        return "ProcessesErrorCategory";
}

string ProcessesErrorCategoryClass::message(int code) const {
        switch (code) {
        case NoError:
                return "Success";
        case SpawnError:
                return "Spawn error";
        case ProcessAlreadyStartedError:
                return "Process already started";
        case NonZeroExitStatusError:
                return "Process returned non-zero exit status";
        }
        assert(false);
        return "Unknown";
}

error::Error MakeError(ProcessesErrorCode code, const string &msg) {
        return error::Error(error_condition(code, ProcessesErrorCategory), msg);
};

void OutputHandler::operator()(const char *data, size_t size) {
        if (size == 0) {
                return;
        }
        // Get rid of exactly one trailing newline, if there is one. This is because
        // we unconditionally print one at the end of every log line. If the string
        // does not contain a trailing newline, add a "{...}" instead, since we
        // cannot avoid breaking the line apart then.
        string content(data, size);
        if (content.back() == '\n') {
                content.pop_back();
        } else {
                content.append("{...}");
        }
        auto lines = mender::common::SplitString(content, "\n");
        for (auto line : lines) {
                log::Info(prefix + line);
        }
}

} // namespace processes
} // namespace common
} // namespace mender

1	// Copyright 2023 Northern.tech AS
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	#include <common/processes.hpp>
16
17	#include <common/log.hpp>
18	#include <common/common.hpp>
19
20	namespace mender {
21	namespace common {
22	namespace processes {
23
24	namespace log = mender::common::log;
25
26	const chrono::seconds DEFAULT_GENERATE_LINE_DATA_TIMEOUT {10};
27
28	const ProcessesErrorCategoryClass ProcessesErrorCategory;
29
30	const char *ProcessesErrorCategoryClass::name() const noexcept {	×
31	return "ProcessesErrorCategory";	×
32	}
33
34	string ProcessesErrorCategoryClass::message(int code) const {	86✔
35	switch (code) {	86✔
36	case NoError:
37	return "Success";	×
38	case SpawnError:
39	return "Spawn error";	×
40	case ProcessAlreadyStartedError:
41	return "Process already started";	×
42	case NonZeroExitStatusError:
43	return "Process returned non-zero exit status";	86✔
44	}
45	assert(false);
46	return "Unknown";	×
47	}
48
49	error::Error MakeError(ProcessesErrorCode code, const string &msg) {	1,796✔
50	return error::Error(error_condition(code, ProcessesErrorCategory), msg);	1,796✔
51	};
52
53	void OutputHandler::operator()(const char *data, size_t size) {	793✔
54	if (size == 0) {	793✔
55	return;	×
56	}
57	// Get rid of exactly one trailing newline, if there is one. This is because
58	// we unconditionally print one at the end of every log line. If the string
59	// does not contain a trailing newline, add a "{...}" instead, since we
60	// cannot avoid breaking the line apart then.
61	string content(data, size);	793✔
62	if (content.back() == '\n') {	793✔
63	content.pop_back();	793✔
64	} else {
UNCOV 65	content.append("{...}");	×
66	}
67	auto lines = mender::common::SplitString(content, "\n");	1,586✔
68	for (auto line : lines) {	1,614✔
69	log::Info(prefix + line);	1,642✔
70	}
71	}	793✔
72
73	} // namespace processes
74	} // namespace common
75	} // namespace mender

mendersoftware / mender / 2410916884

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous