Light

Specifies a date and time, using individual members for the month, day, year, weekday, hour, minute, second, and millisecond. The time is either in coordinated universal time (UTC) or local time, depe...

Many Dell Precision 7720 laptop users with Microsoft Windows 10, Version 20H2 face the following events showing up in the Windows System Event Viewer. Let me paste the event, <Event xmlns=" <System> <Provider Name="nhi" /> <EventID Qualifiers="16384">1</EventID> <Version>0</Version> <Level>4</Level> <Task>0</Task> <Opcode>0</Opcode> <Keywords>0x80000000000000</Keywords> <TimeCreated SystemTime="2021-12-01T11:50:49.4168316Z" /> <EventRecordID>143446</EventRecordID> <Correlation /> <Execution ProcessID="4" ThreadID="22492" /> <Channel>System</Channel> <Computer>Precision-7720</Computer> <Security /> </System> <EventData> <Data /> <Binary>00000000010000000000000001000040000000000000000000000000000000000000000000000000</Binary> </EventData> </Event>

I think you can accomplish this by wrapping whatever formatter you're already using (The default is `Format<Full, SystemTime>`, obtainable via the `format()` function) in a custom struct with a `FormatEvent` impl that passes the arguments to the inner formatter's `format_event()` and then calls `writeln!(writer)`. Then you just pass this custom struct to the `event_format()` method of the `Layer` or `SubscriberBuilder` you're constructing. I'd show an example, but the tracing system has so many bells & whistles that whatever I came up with likely wouldn't directly map onto whatever your code is doing.

Hi kpreid, That was exactly the idea, our rust app already receives hashes as java longs (i64). Here I'm missing something, obviously I don't understand how this works. `delay: Cache<i64, SystemTime, BuildHasherDefault<NoHashHasher<i64>>>` Here the cache key is of type i64, this i64 is the hash our app is receiving from java. When I perform: let now = SystemTime::now(); let closure = || now; let creation_time = delay.get_with(key, async { closure() }).await; What I though is the "nohashhasher" did nothing with the key, so it used the same i64 (the key I'm passing to the "get_with" method) as a hash. So, in case "get_with" does not found the "key", it performs a "delay.insert(key, now)". So I don't understand why the value (SystemTime) matters, when only the keys are hashed. Thanks, Joan.

`NoHashHasher` only allows a `Hasher::write` call, but `SystemTime` uses multiple `Hasher::write` calls like pretty much every type other than primitive values. According to the documentation of `NoHashHasher`: > `NoHashHasher` does not implement any hashing algorithm and can only be used with types which can be mapped directly to a numeric value. Out of the box `NoHashHasher` is enabled for `u8`, `u16`, `u32`, `u64`, `usize`, `i8`, `i16`, `i32`, `i64`, and `isize`. Types that should be used with `NoHashHasher` need to implement `IsEnabled` and by doing so assert that their `Hash` impl invokes _only one_ of the `Hasher::write_{u8, u16, u32, u64, usize, i8, i16, i32, i64, isize}` methods _exactly once_. In other words, you can't use `NoHashHasher` with `SystemTime`.

Hello, newbie in rust and using moka future cache, my first post here, sorry in advance if I do something wrong. If I declare: `delay: Cache<i64, SystemTime>` And create a new instance: delay: Cache::builder().max_capacity(10).time_to_live(Duration::from_secs(60)).build() And insert into it: let now = SystemTime::now(); let closure = || now; let creation_time = entry.delay.get_with(key, async { closure() }).await; This works perfectly. But if I change the declaration to: `delay: Cache<i64, SystemTime, BuildHasherDefault<NoHashHasher<i64>>>` And create a new instance: delay: `Cache::builder().max_capacity(10).time_to_live(Duration::from_secs(60)).build_with_hasher(BuildNoHashHasher::<i64>::default())` And try to insert a value exactly in the same way, I get the following error: thread 'main' panicked at C:\Users\joanb.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\nohash-hasher-0.2.0\src\lib.rs:244:9: NoHashHasher: second write attempt detected. I would like to understand what's wrong here. Thanks!, Joan.

Thanks a lot bjorn, I will use SystemTime as_millis to insert a u64.

AI is great, but doesn't want to learn Rust and programming any further. For example, fn seconds_from_epoch(year: u32, month: u32, day: u32) -> u64 { // Create a `SystemTime` instance for the given date let date = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs( (year as u64 - 1970) * 31_556_952 + // seconds in a year (month as u64 - 1) * 2_592_000 + // seconds in a month (approx) (day as u64 - 1) * 86_400 // seconds in a day ); // Calculate the duration since the Unix epoch let duration_since_epoch = date.duration_since(UNIX_EPOCH).expect("Time went backwards"); // Return the number of seconds duration_since_epoch.as_secs() } This function is written by AI and corrected by me. AI did the following mistakes, 1. AI used as i64, although the function result was provided as u64; so it should learn Rust better 2. AI used a year duration as 31_556_000, although a year is a little longer I pointed on these AI mistakes over 6 months ago, but still AI did nothing to correct own mistakes.

You can use `UNIX_EPOCH + Duration::from_millis(n)` to get a `SystemTime`, but the standard library doesn't have date/time formatting. You might like the `humantime` crate for that, for example using `format_rfc3339_millis`.

DragonDev1906: > "this has to return a Result due to its trait, but it is and will stay Infallible" (changing that would be a breaking change): There's a bunch of places _in the stdlib_ that could use that! For example, AFAICT `std::fs::Metadata::modified` and a bunch of its friends were made to return `io::Result<SystemTime>` for purely theoretical reasons and they can't actually ever fail on any supported system. To be most useful, though, this annotation would have to make it so the return type _behaves like_ `Result<T, !>` for purpose of things like being able to call `into_ok`, and that's a weird wrinkle to add to the type system.

Isn't that more easily handled with `fn modified(…) -> io::Result<SystemTime> { Ok(self.modified_impl()) }` and an associated comment? (Other than the `into_ok` nice-to-have.)

DragonDev1906: > "this has to return a Result due to its trait, but it is and will stay Infallible" (changing that would be a breaking change): There's a bunch of places _in the stdlib_ that could use that! For example, AFAICT `std::fs::Metadata::modified` and a bunch of its friends were made to return `io::Result<SystemTime>` for purely theoretical reasons and they can't actually ever fail on any supported system. To be most useful, though, this annotation would have to make it so the return type _behaves like_ `Result<T, !>` for purpose of things like being able to call `into_ok`, and that's a weird wrinkle to add to the type system.

Isn't that more easily handled with `fn modified(…) -> io::Result<SystemTime> { Ok(self.modified_impl()) }` and an associated comment? (Other than the `into_ok` nice-to-have.)

Why not just use SystemTime for this? Why do you want an Instant?

SystemTime comes from CLOCK_REALTIME, whereas Instant comes from CLOCK_MONOTONIC, so using SystemTime would be inconsistent. You could make two arbitrary SystemTime values but they would be incompatible with SystemTime::now(), whereas the CLOCK_MONOTONIC values from the receipt timestamp are compatible with Instant::now() on FreeBSD (and it would be convenient to be able to use that with them). It's also idiomatic for some libraries to take Instants to represent monotonic clock values, which would make sense to use in this case.

I'm working with OS-level UDP packet timestamps in FreeBSD. In general this is a feature (SO_TIMESTAMP) in some operating systems that lets you access the time that the OS received a packet -- as opposed to when your application called recv() for it -- as a control message on that packet. It comes in as either a Timespec or a Timeval depending on your configuration. On Linux, the time value comes from CLOCK_REALTIME, and you can construct a SystemTime from this by converting it to a duration and adding it to SystemTime::UNIX_EPOCH. FreeBSD has a specific socket feature (SO_TS_MONOTONIC) that lets you get these sockets from CLOCK_MONOTONIC, which, on FreeBSD, is the same clock that Instant is sourced from. It would be useful to be able to create an actual Instant from this Timespec, given that the underlying Instant on FreeBSD is also a Timespec from the same clock. There's a really dreadful and somewhat dubious way to do this by creating a `mem::zeroed` Instant and adding a Duration to it, but it would be nice if instead there was an OS-specific extension that let you create an Instant from a Timespec. Is this worth proposing more formally?

I’m not sure if this would help. This is the last event that I know of; before I come into my office and find that the PC fan is in fact spinning, but the pc is infact asleep/ or not. Everything else except shrinkwrapping my PC is obsolete - System - Provider [ Name] DSAService - EventID 2003 [ Qualifiers] 0 Version 0 Level 4 Task 0 Opcode 0 Keywords 0x80000000000000 - TimeCreated [ SystemTime] 2025-04-26T05:03:04.6495835Z EventRecordID 53289 Correlation - Execution [ ProcessID] 0 [ ThreadID] 0 Channel Application Computer Scarlett Security - EventData <DSAExceptionEvent xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="https://www.intel.com"><OS><Description>Windows 10 Education</Description><Version>6.3</Version><Build>19045</Build><Release>2009</Release><EpmId>windows-10-22h2-64</EpmId></OS><DSAVersion>25.2.15.9</DSAVersion><Module>DSAExternalService.dll</Module><ClassName>DSAExternalService.External</ClassName><MethodName>GetProductsAndDownloads</MethodName><ExceptionType>NullReferenceException</ExceptionType><Message>Object reference not set to an instance of an object.</Message></DSAExceptionEvent>