Current section
Files
Jump to
Current section
Files
src/observer_cli_log.erl
-module(observer_cli_log).
-include_lib("kernel/include/file.hrl").
-export([addressable_handler_id/1, capture/1, valid_request/1]).
-ifdef(TEST).
-export([
capture/2,
classify_config/2,
plain_modes/1,
read_configured_file/2,
tail/4
]).
-endif.
-define(MAX_TAIL, 2000).
-define(MAX_HANDLER_IDS, 64).
-define(MAX_HANDLER_ID_BYTES, 1024).
-define(MAX_HANDLER_ID_CODEPOINTS, 255).
-define(MAX_PATH_BYTES, 4096).
-define(MAX_MODES, 32).
-define(MAX_READ_BYTES, 64 * 1024).
-define(MAX_LINE_BYTES, 32 * 1024).
-define(MAX_OFFSET, 16#7FFFFFFFFFFFFFFF).
-spec capture(map()) -> tuple().
capture(Request) ->
capture(Request, default_env()).
capture(Request, Env) ->
State = #{handler_ids_enumerated => false, lookups => 0, attempts => 0},
case valid_request(Request) of
true ->
case call_env(os_type, [], Env) of
{unix, Platform} when Platform =:= linux; Platform =:= darwin ->
select_source(Request, Env, State);
_ ->
unavailable(
unsupported_target_platform,
data([], null, null),
[],
State
)
end;
false ->
{probe_error, invalid_request}
end.
-spec valid_request(term()) -> boolean().
valid_request(#{handler := Handler, tail := Tail} = Request) ->
map_size(Request) =:= 2 andalso
(Handler =:= null orelse
(is_binary(Handler) andalso addressable_handler_id(Handler))) andalso
is_integer(Tail) andalso Tail >= 1 andalso Tail =< ?MAX_TAIL;
valid_request(_Request) ->
false.
select_source(#{handler := null, tail := Tail}, Env, State0) ->
State = State0#{handler_ids_enumerated := true},
case handler_ids(Env) of
{ok, Ids} ->
case bounded_ids(Ids, [], 0) of
{ok, BoundedIds} ->
{Sources, State1} = classify_ids(BoundedIds, Env, State, []),
Supported = [Source || #{supported := true} = Source <- Sources],
select_automatic(Sources, Supported, Tail, Env, State1);
too_many ->
unavailable(scan_budget_exceeded, data([], null, null), [], State);
invalid ->
unavailable(
log_source_unavailable,
data([], null, null),
[source_classification_complete],
State
)
end;
error ->
unavailable(
log_source_unavailable,
data([], null, null),
[source_classification_complete],
State
)
end;
select_source(#{handler := Handler, tail := Tail}, Env, State) ->
case existing_handler_atom(Handler) of
{ok, Id} ->
{Result, State1} = lookup_config(Id, Env, State),
case Result of
{error, {not_found, _MissingId}} ->
unavailable(
log_handler_not_found,
data([], null, null),
[source_classification_complete],
State1
);
_ ->
select_explicit_config(Id, Result, Tail, Env, State1)
end;
error ->
unavailable(
log_handler_not_found,
data([], null, null),
[source_classification_complete],
State
)
end.
select_explicit_config(Id, Result, Tail, Env, State) ->
Source = classify_config(Id, Result),
case maps:get(supported, Source) of
true ->
selected_capture(Source, [Source], Tail, Env, State);
false ->
unavailable(
maps:get(reason_code, maps:get(summary, Source)),
data([public_summary(Source)], null, null),
[source_classification_complete],
State
)
end.
select_automatic(Sources, [Source], Tail, Env, State) ->
selected_capture(Source, Sources, Tail, Env, State);
select_automatic(Sources, [], _Tail, _Env, State) ->
unavailable(
log_source_unavailable,
data(public_summaries(Sources), null, null),
[source_classification_complete],
State
);
select_automatic(Sources, _Multiple, _Tail, _Env, State) ->
unavailable(
log_handler_required,
data(public_summaries(Sources), null, null),
[source_classification_complete],
State
).
handler_ids(Env) ->
try call_env(handler_ids, [], Env) of
Ids -> {ok, Ids}
catch
_:_ -> error
end.
bounded_ids([], Acc, _Count) ->
{ok, lists:reverse(Acc)};
bounded_ids([_Id | _Rest], _Acc, ?MAX_HANDLER_IDS) ->
too_many;
bounded_ids([Id | Rest], Acc, Count) when is_atom(Id) ->
bounded_ids(Rest, [Id | Acc], Count + 1);
bounded_ids([_Id | _Rest], _Acc, _Count) ->
invalid;
bounded_ids(_Improper, _Acc, _Count) ->
invalid.
classify_ids([], _Env, State, Acc) ->
{lists:reverse(Acc), State};
classify_ids([Id | Rest], Env, State0, Acc) ->
{Result, State} = lookup_config(Id, Env, State0),
classify_ids(Rest, Env, State, [classify_config(Id, Result) | Acc]).
lookup_config(Id, Env, State) ->
State1 = State#{lookups := maps:get(lookups, State) + 1},
Result =
try call_env(handler_config, [Id], Env) of
Value -> Value
catch
_:_ -> error
end,
{Result, State1}.
-spec classify_config(atom(), term()) -> map().
classify_config(Id, Result) when is_atom(Id) ->
IdText = atom_to_binary(Id, utf8),
Addressable = addressable_handler_id(IdText),
classify_config_result(Id, IdText, Addressable, Result);
classify_config(_Id, _Result) ->
unsupported_source(<<"--invalid-handler-id">>, false, other, invalid_log_handler_config).
classify_config_result(
Id,
IdText,
Addressable,
{ok, #{id := ConfigId, module := Module, config := Config}}
) when ConfigId =:= Id, is_atom(Module), is_map(Config) ->
case maps:find(type, Config) of
{ok, Type} when Module =/= logger_std_h; Type =/= file ->
unsupported_source(IdText, Addressable, other, unsupported_log_handler);
{ok, file} ->
classify_file_config(Id, IdText, Addressable, Config);
error ->
unsupported_source(IdText, Addressable, other, invalid_log_handler_config)
end;
classify_config_result(_Id, IdText, Addressable, _Result) ->
unsupported_source(IdText, Addressable, other, invalid_log_handler_config).
classify_file_config(Id, IdText, Addressable, Config) ->
case {maps:find(file, Config), maps:find(modes, Config)} of
{{ok, Path}, {ok, Modes}} ->
classify_file_shape(Id, IdText, Addressable, Path, Modes);
_ ->
unsupported_source(
IdText,
Addressable,
logger_std_h_file,
invalid_log_handler_config
)
end.
classify_file_shape(Id, IdText, Addressable, Path, Modes) ->
case valid_file_shape(Path, IdText, Modes) of
{ok, supported} ->
classify_display_path(Id, IdText, Addressable, Path, Modes);
{ok, unsupported} ->
unsupported_source(
IdText, Addressable, logger_std_h_file, unsupported_file_modes
);
error ->
unsupported_source(
IdText, Addressable, logger_std_h_file, invalid_log_handler_config
)
end.
classify_display_path(Id, IdText, Addressable, Path, Modes) ->
case display_path(Path) of
{ok, DisplayPath} ->
Summary = summary(
IdText,
Addressable,
logger_std_h_file,
true,
case Addressable of
true -> null;
false -> unaddressable_handler_id
end
),
#{
supported => true,
id => Id,
path => Path,
display_path => DisplayPath,
modes => Modes,
critical => {Id, logger_std_h, file, Path, Modes},
summary => Summary
};
error ->
unsupported_source(
IdText, Addressable, logger_std_h_file, log_path_unrepresentable
)
end.
valid_file_shape(Path, IdText, Modes) ->
case
proper_flat_filename(Path) andalso absolute_path(Path) andalso
valid_handler_id_size(IdText)
of
true -> plain_modes(Modes);
false -> error
end.
-spec plain_modes(term()) -> {ok, supported | unsupported} | error.
plain_modes(Modes) ->
bounded_modes(Modes, 0, supported).
bounded_modes([], _Count, Status) ->
{ok, Status};
bounded_modes([_Mode | _Rest], ?MAX_MODES, _Status) ->
error;
bounded_modes([Mode | Rest], Count, Status) ->
case mode_status(Mode) of
invalid -> error;
unsupported -> bounded_modes(Rest, Count + 1, unsupported);
supported -> bounded_modes(Rest, Count + 1, Status)
end;
bounded_modes(_Improper, _Count, _Status) ->
error.
mode_status(Mode) when
Mode =:= read;
Mode =:= write;
Mode =:= append;
Mode =:= exclusive;
Mode =:= raw;
Mode =:= binary;
Mode =:= sync;
Mode =:= delayed_write;
Mode =:= read_ahead
->
supported;
mode_status({delayed_write, Size, Delay}) when
is_integer(Size),
Size >= 0,
Size =< 16#7FFFFFFF,
is_integer(Delay),
Delay >= 0,
Delay =< 16#7FFFFFFF
->
supported;
mode_status({read_ahead, Size}) when
is_integer(Size), Size >= 1, Size =< 16#7FFFFFFF
->
supported;
mode_status({delayed_write, _Size, _Delay}) ->
invalid;
mode_status({read_ahead, _Size}) ->
invalid;
mode_status(_Mode) ->
unsupported.
unsupported_source(IdText, Addressable, Kind, Reason) ->
#{
supported => false,
summary => summary(IdText, Addressable, Kind, false, Reason)
}.
summary(Id, Addressable, Kind, Supported, Reason) ->
#{
id => Id,
addressable => Addressable,
handler_kind => Kind,
supported => Supported,
reason_code => Reason
}.
public_summary(#{summary := Summary}) -> Summary.
public_summaries(Sources) -> [public_summary(Source) || Source <- Sources].
selected_source(Source) ->
(public_summary(Source))#{
configured_path => maps:get(display_path, Source),
active_handler_fd_match => unknown
}.
selected_capture(Source, Sources, TailCount, Env, State) ->
read_selected(Source, Sources, TailCount, Env, State, 1).
read_selected(Source, Sources, TailCount, Env, State0, Attempt) ->
case read_configured_file(Source, Env, State0) of
{ok, Buffer, CapturedEof, Coverage, State} ->
finish_read(
Source, Sources, TailCount, Buffer, CapturedEof, Coverage, Env, State, Attempt
);
{race, Coverage, State} when Attempt =:= 1 ->
retry_baseline(Source, Sources, TailCount, Coverage, Env, State);
{race, Coverage, State} ->
selected_unavailable(log_source_changed, Source, Sources, Coverage, State);
{error, Reason, Coverage, State} ->
selected_unavailable(Reason, Source, Sources, Coverage, State)
end.
retry_baseline(Source, Sources, TailCount, Coverage, Env, State0) ->
case rechecked_source(Source, Env, State0) of
{ok, NewSource, State} ->
read_selected(NewSource, Sources, TailCount, Env, State, 2);
{error, State} ->
selected_unavailable(log_source_changed, Source, Sources, Coverage, State)
end.
finish_read(
Source,
Sources,
TailCount,
Buffer,
CapturedEof,
Coverage,
Env,
State0,
Attempt
) ->
case rechecked_source(Source, Env, State0) of
{ok, CheckedSource, State} ->
case same_source(Source, CheckedSource) of
true ->
finish_tail(
CheckedSource,
Sources,
TailCount,
Buffer,
CapturedEof,
Coverage ++ [post_read_verified],
State
);
false when Attempt =:= 1 ->
read_selected(CheckedSource, Sources, TailCount, Env, State, 2);
false ->
selected_unavailable(log_source_changed, Source, Sources, Coverage, State)
end;
{error, State} ->
selected_unavailable(log_source_changed, Source, Sources, Coverage, State)
end.
rechecked_source(Source, Env, State0) ->
Id = maps:get(id, Source),
{Result, State} = lookup_config(Id, Env, State0),
Checked = classify_config(Id, Result),
case maps:get(supported, Checked) of
true -> {ok, Checked, State};
false -> {error, State}
end.
same_source(Left, Right) ->
maps:get(critical, Left) =:= maps:get(critical, Right).
finish_tail(Source, Sources, Requested, Buffer, CapturedEof, Coverage, State) ->
Start = CapturedEof - byte_size(Buffer),
Tail = tail(Buffer, Start, CapturedEof, Requested),
Data = data(public_summaries(Sources), selected_source(Source), Tail),
case maps:get(content_truncated, Tail) of
false ->
{ok, Data, Coverage, [effect(State)]};
true ->
Reason =
case maps:get(truncation_reasons, Tail) of
[byte_cap | _] -> log_byte_cap_reached;
_ -> log_line_cap_reached
end,
{error, Reason, Data, Coverage, [effect(State)]}
end.
selected_unavailable(Reason, Source, Sources, Coverage, State) ->
unavailable(
Reason,
data(public_summaries(Sources), selected_source(Source), null),
Coverage,
State
).
-ifdef(TEST).
read_configured_file(Source, Env) ->
State = #{handler_ids_enumerated => false, lookups => 0, attempts => 0},
read_configured_file(Source, Env, State).
-endif.
read_configured_file(Source, Env, State0) ->
State = State0#{attempts := maps:get(attempts, State0) + 1},
Path = maps:get(path, Source),
case call_file(read_link_info, [Path], Env) of
{ok, #file_info{type = regular} = PathInfo} ->
open_configured_file(Path, PathInfo, Env, State);
{ok, #file_info{}} ->
{error, unsupported_log_file_type, [source_classification_complete, source_selected],
State};
{error, _Reason} ->
{error, log_file_unavailable, [source_classification_complete, source_selected], State};
_ ->
{error, log_file_read_failed, [source_classification_complete, source_selected], State}
end.
open_configured_file(Path, PathInfo, Env, State) ->
Coverage = [source_classification_complete, source_selected, path_prechecked],
case call_file(open, [Path], Env) of
{ok, Fd} ->
try
read_open_file(Path, PathInfo, Fd, Env, State, Coverage)
after
_ = call_file(close, [Fd], Env)
end;
{error, enoent} ->
{race, Coverage, State};
{error, _Reason} ->
{error, log_file_unavailable, Coverage, State};
_ ->
{error, log_file_read_failed, Coverage, State}
end.
read_open_file(Path, PathInfo, Fd, Env, State, Coverage) ->
case call_file(read_file_info, [Fd], Env) of
{ok, #file_info{type = regular} = FdInfo} ->
case {file_identity(PathInfo), file_identity(FdInfo)} of
{{ok, Identity}, {ok, Identity}} ->
read_seekable_file(
Path,
Identity,
Fd,
Env,
State,
Coverage ++ [fd_identity_verified]
);
{{ok, _}, {ok, _}} ->
{race, Coverage, State};
_ ->
{error, log_file_identity_unavailable, Coverage, State}
end;
{ok, #file_info{}} ->
{error, unsupported_log_file_type, Coverage, State};
{error, _Reason} ->
{error, log_file_read_failed, Coverage, State};
_ ->
{error, log_file_read_failed, Coverage, State}
end.
read_seekable_file(Path, Identity, Fd, Env, State, Coverage) ->
case call_file(position, [Fd], Env) of
{ok, CapturedEof} when
is_integer(CapturedEof), CapturedEof >= 0, CapturedEof =< ?MAX_OFFSET
->
Start = max(0, CapturedEof - ?MAX_READ_BYTES),
Length = CapturedEof - Start,
case pread(Fd, Start, Length, Env) of
{ok, Buffer} when byte_size(Buffer) =:= Length ->
verify_after_read(
Path,
Identity,
Fd,
Buffer,
CapturedEof,
Env,
State,
Coverage ++ [bytes_captured]
);
{ok, _Short} ->
{race, Coverage, State};
eof ->
{race, Coverage, State};
_ ->
{error, log_file_read_failed, Coverage, State}
end;
{error, _Reason} ->
{error, unsupported_log_file_type, Coverage, State};
_ ->
{error, log_file_read_failed, Coverage, State}
end.
pread(_Fd, _Start, 0, _Env) ->
{ok, <<>>};
pread(Fd, Start, Length, Env) ->
call_file(pread, [Fd, Start, Length], Env).
verify_after_read(Path, Identity, Fd, Buffer, CapturedEof, Env, State, Coverage) ->
case call_file(read_file_info, [Fd], Env) of
{ok, #file_info{type = regular, size = Size} = FdInfo} when
is_integer(Size), Size >= CapturedEof
->
case file_identity(FdInfo) of
{ok, Identity} ->
verify_path_after_read(
Path, Identity, Buffer, CapturedEof, Env, State, Coverage
);
{ok, _Changed} ->
{race, Coverage, State};
error ->
{error, log_file_identity_unavailable, Coverage, State}
end;
{ok, #file_info{type = regular}} ->
{race, Coverage, State};
{ok, #file_info{}} ->
{error, unsupported_log_file_type, Coverage, State};
_ ->
{error, log_file_read_failed, Coverage, State}
end.
verify_path_after_read(Path, Identity, Buffer, CapturedEof, Env, State, Coverage) ->
case call_file(read_link_info, [Path], Env) of
{ok, #file_info{type = regular} = PathInfo} ->
case file_identity(PathInfo) of
{ok, Identity} -> {ok, Buffer, CapturedEof, Coverage, State};
{ok, _Changed} -> {race, Coverage, State};
error -> {error, log_file_identity_unavailable, Coverage, State}
end;
{ok, #file_info{}} ->
{error, unsupported_log_file_type, Coverage, State};
{error, _Reason} ->
{race, Coverage, State};
_ ->
{error, log_file_read_failed, Coverage, State}
end.
file_identity(#file_info{major_device = Major, inode = Inode}) when
is_integer(Major), Major >= 0, is_integer(Inode), Inode > 0
->
{ok, {Major, Inode}};
file_identity(_Info) ->
error.
-spec tail(binary(), non_neg_integer(), non_neg_integer(), 1..?MAX_TAIL) -> map().
tail(Buffer, Start, CapturedEof, Requested) when
is_binary(Buffer),
is_integer(Start),
Start >= 0,
is_integer(CapturedEof),
CapturedEof >= byte_size(Buffer),
is_integer(Requested),
Requested >= 1,
Requested =< ?MAX_TAIL
->
{Segments, TailLimited} = physical_tail(Buffer, Requested),
ByteFragment = Start > 0 andalso not TailLimited,
{Lines, LineIndexes} = cap_lines(Segments, ByteFragment, 0, [], []),
ByteIndexes =
case ByteFragment andalso Lines =/= [] of
true -> [0];
false -> []
end,
Indexes = lists:usort(ByteIndexes ++ LineIndexes),
Reasons0 =
case ByteIndexes of
[] -> [];
_ -> [byte_cap]
end,
Reasons =
case LineIndexes of
[] -> Reasons0;
_ -> Reasons0 ++ [line_cap]
end,
ContentTruncated = Reasons =/= [],
HasMore = Start > 0 orelse TailLimited orelse ContentTruncated,
#{
scope => configured_path,
active_handler_fd_match => unknown,
visibility => reader_visible,
command_filesync_requested => false,
consistency => non_atomic,
content_trust => untrusted,
requested_lines => Requested,
returned_lines => length(Lines),
captured_eof_bytes => CapturedEof,
bytes_read => byte_size(Buffer),
has_more => HasMore,
content_truncated => ContentTruncated,
truncation_reasons => Reasons,
truncated_line_indexes => Indexes,
lines => Lines
}.
physical_tail(<<>>, _Requested) ->
{[], false};
physical_tail(Buffer, Requested) ->
Size = byte_size(Buffer),
{Position, End} =
case binary:at(Buffer, Size - 1) of
$\n -> {Size - 2, Size - 1};
_ -> {Size - 1, Size}
end,
scan_lines(Buffer, Position, End, Requested, []).
scan_lines(Buffer, Position, End, Remaining, Acc) when Position >= 0 ->
case binary:at(Buffer, Position) of
$\n ->
Segment = segment(Buffer, Position + 1, End),
case Remaining of
1 -> {[Segment | Acc], true};
_ -> scan_lines(Buffer, Position - 1, Position, Remaining - 1, [Segment | Acc])
end;
_ ->
scan_lines(Buffer, Position - 1, End, Remaining, Acc)
end;
scan_lines(Buffer, _Position, End, _Remaining, Acc) ->
{[segment(Buffer, 0, End) | Acc], false}.
segment(Buffer, Start, End) ->
Length = End - Start,
Raw = binary:part(Buffer, Start, Length),
case Raw of
<<Prefix:(Length - 1)/binary, $\r>> when Length > 0 -> Prefix;
_ -> Raw
end.
cap_lines([], _ByteFragment, _Index, Lines, Indexes) ->
{lists:reverse(Lines), lists:reverse(Indexes)};
cap_lines([Line | Rest], ByteFragment, Index, Lines, Indexes) when
byte_size(Line) > ?MAX_LINE_BYTES
->
Start = byte_size(Line) - ?MAX_LINE_BYTES,
Capped = skip_leading_continuations(binary:part(Line, Start, ?MAX_LINE_BYTES), 3),
cap_lines(Rest, ByteFragment, Index + 1, [Capped | Lines], [Index | Indexes]);
cap_lines([Line | Rest], ByteFragment, Index, Lines, Indexes) ->
Capped =
case ByteFragment andalso Index =:= 0 of
true -> skip_leading_continuations(Line, 3);
false -> Line
end,
cap_lines(Rest, ByteFragment, Index + 1, [Capped | Lines], Indexes).
skip_leading_continuations(<<Byte, Rest/binary>>, Remaining) when
Remaining > 0, Byte >= 16#80, Byte =< 16#BF
->
skip_leading_continuations(Rest, Remaining - 1);
skip_leading_continuations(Binary, _Remaining) ->
Binary.
-spec addressable_handler_id(unicode:chardata()) -> boolean().
addressable_handler_id(Text) ->
case unicode:characters_to_binary(Text) of
Binary when is_binary(Binary) ->
case unicode:characters_to_list(Binary) of
Codepoints when is_list(Codepoints) ->
valid_handler_id_size(Binary) andalso
not starts_option(Binary) andalso
lists:all(fun safe_handler_codepoint/1, Codepoints);
_ ->
false
end;
_ ->
false
end.
valid_handler_id_size(Binary) ->
byte_size(Binary) >= 1 andalso byte_size(Binary) =< ?MAX_HANDLER_ID_BYTES andalso
case unicode:characters_to_list(Binary) of
Codepoints when is_list(Codepoints) ->
length(Codepoints) =< ?MAX_HANDLER_ID_CODEPOINTS;
_ ->
false
end.
starts_option(<<"--", _/binary>>) -> true;
starts_option(_Binary) -> false.
safe_handler_codepoint(Codepoint) ->
not terminal_control(Codepoint).
terminal_control(Codepoint) when Codepoint < 16#20 -> true;
terminal_control(Codepoint) when Codepoint >= 16#7F, Codepoint =< 16#9F -> true;
terminal_control(16#061C) -> true;
terminal_control(16#200E) -> true;
terminal_control(16#200F) -> true;
terminal_control(16#2028) -> true;
terminal_control(16#2029) -> true;
terminal_control(Codepoint) when Codepoint >= 16#202A, Codepoint =< 16#202E -> true;
terminal_control(Codepoint) when Codepoint >= 16#2066, Codepoint =< 16#2069 -> true;
terminal_control(_Codepoint) -> false.
proper_flat_filename([]) -> false;
proper_flat_filename(Path) -> proper_flat_filename_tail(Path).
proper_flat_filename_tail([]) ->
true;
proper_flat_filename_tail([Character | Rest]) when
is_integer(Character), Character >= 0, Character < 16#D800
->
proper_flat_filename_tail(Rest);
proper_flat_filename_tail([Character | Rest]) when
is_integer(Character), Character > 16#DFFF, Character =< 16#10FFFF
->
proper_flat_filename_tail(Rest);
proper_flat_filename_tail(_Improper) ->
false.
absolute_path(Path) ->
try filename:pathtype(Path) of
absolute -> true;
_ -> false
catch
_:_ -> false
end.
display_path(Path) ->
case unicode:characters_to_binary(Path) of
Binary when is_binary(Binary), byte_size(Binary) =< ?MAX_PATH_BYTES ->
case unicode:characters_to_list(Binary) of
Path -> {ok, Binary};
_ -> error
end;
_ ->
error
end.
existing_handler_atom(Handler) ->
try binary_to_existing_atom(Handler, utf8) of
Id -> {ok, Id}
catch
error:badarg -> error;
error:system_limit -> error
end.
data(Sources, Selected, Tail) ->
#{sources => Sources, selected_source => Selected, tail => Tail}.
unavailable(Reason, Data, Coverage, State) ->
{unavailable, Reason, Data, Coverage, [effect(State)]}.
effect(State) ->
#{
id => configured_log_read,
handler_ids_enumerated => maps:get(handler_ids_enumerated, State),
handler_config_lookups => maps:get(lookups, State),
read_attempts => maps:get(attempts, State),
raw_read_cap_bytes => ?MAX_READ_BYTES,
atime_may_change => true,
consistency => non_atomic,
command_filesync_attempted => false
}.
default_env() ->
#{
os_type => fun os:type/0,
handler_ids => fun logger:get_handler_ids/0,
handler_config => fun logger:get_handler_config/1,
read_link_info => fun(Path) -> file:read_link_info(Path, [raw]) end,
open => fun(Path) -> file:open(Path, [read, binary, raw]) end,
read_file_info => fun(Fd) -> file:read_file_info(Fd, [raw]) end,
position => fun(Fd) -> file:position(Fd, eof) end,
pread => fun file:pread/3,
close => fun file:close/1
}.
call_env(Key, Arguments, Env) ->
erlang:apply(maps:get(Key, Env), Arguments).
call_file(Key, Arguments, Env) ->
try call_env(Key, Arguments, Env) of
Result -> Result
catch
_:_ -> {error, failed}
end.