mirror of
https://github.com/servo/servo.git
synced 2025-06-06 16:45:39 +00:00
7c574141c0
This change creates a `constellation_traits` crate. Previously messages to the `Constellation` were in the `compositing_traits` crate, which came about organically. This change moves these to a new crate which also contains data types that are used in both compositing/libservo and script (ie types that cross the process boundary). The idea is similar to `embedding_traits`, but this is meant for types not exposed to the API. This change allows deduplicating `UntrustedNodeAddress`, which previously had two versions to avoid circular dependencies. Signed-off-by: Martin Robinson <mrobinson@igalia.com>
115 lines
3.9 KiB
Rust
115 lines
3.9 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
|
|
|
|
//! The constellation uses logging to perform crash reporting.
|
|
//! The constellation receives all `warn!`, `error!` and `panic!` messages,
|
|
//! and generates a crash report when it receives a panic.
|
|
|
|
use std::borrow::ToOwned;
|
|
use std::sync::Arc;
|
|
use std::thread;
|
|
|
|
use backtrace::Backtrace;
|
|
use base::id::WebViewId;
|
|
use constellation_traits::{ConstellationMsg as FromCompositorMsg, LogEntry};
|
|
use crossbeam_channel::Sender;
|
|
use log::{Level, LevelFilter, Log, Metadata, Record};
|
|
use parking_lot::ReentrantMutex;
|
|
use script_traits::{ScriptMsg as FromScriptMsg, ScriptToConstellationChan};
|
|
|
|
/// A logger directed at the constellation from content processes
|
|
/// #[derive(Clone)]
|
|
pub struct FromScriptLogger {
|
|
/// A channel to the constellation
|
|
pub script_to_constellation_chan: Arc<ReentrantMutex<ScriptToConstellationChan>>,
|
|
}
|
|
|
|
/// A logger directed at the constellation from content processes
|
|
impl FromScriptLogger {
|
|
/// Create a new constellation logger.
|
|
pub fn new(script_to_constellation_chan: ScriptToConstellationChan) -> FromScriptLogger {
|
|
FromScriptLogger {
|
|
script_to_constellation_chan: Arc::new(ReentrantMutex::new(
|
|
script_to_constellation_chan,
|
|
)),
|
|
}
|
|
}
|
|
|
|
/// The maximum log level the constellation logger is interested in.
|
|
pub fn filter(&self) -> LevelFilter {
|
|
LevelFilter::Warn
|
|
}
|
|
}
|
|
|
|
impl Log for FromScriptLogger {
|
|
fn enabled(&self, metadata: &Metadata) -> bool {
|
|
metadata.level() <= Level::Warn
|
|
}
|
|
|
|
fn log(&self, record: &Record) {
|
|
if let Some(entry) = log_entry(record) {
|
|
let thread_name = thread::current().name().map(ToOwned::to_owned);
|
|
let msg = FromScriptMsg::LogEntry(thread_name, entry);
|
|
let chan = self.script_to_constellation_chan.lock();
|
|
let _ = chan.send(msg);
|
|
}
|
|
}
|
|
|
|
fn flush(&self) {}
|
|
}
|
|
|
|
/// A logger directed at the constellation from the compositor
|
|
#[derive(Clone)]
|
|
pub struct FromCompositorLogger {
|
|
/// A channel to the constellation
|
|
pub constellation_chan: Arc<ReentrantMutex<Sender<FromCompositorMsg>>>,
|
|
}
|
|
|
|
impl FromCompositorLogger {
|
|
/// Create a new constellation logger.
|
|
pub fn new(constellation_chan: Sender<FromCompositorMsg>) -> FromCompositorLogger {
|
|
FromCompositorLogger {
|
|
constellation_chan: Arc::new(ReentrantMutex::new(constellation_chan)),
|
|
}
|
|
}
|
|
|
|
/// The maximum log level the constellation logger is interested in.
|
|
pub fn filter(&self) -> LevelFilter {
|
|
LevelFilter::Warn
|
|
}
|
|
}
|
|
|
|
impl Log for FromCompositorLogger {
|
|
fn enabled(&self, metadata: &Metadata) -> bool {
|
|
metadata.level() <= Level::Warn
|
|
}
|
|
|
|
fn log(&self, record: &Record) {
|
|
if let Some(entry) = log_entry(record) {
|
|
let top_level_id = WebViewId::installed();
|
|
let thread_name = thread::current().name().map(ToOwned::to_owned);
|
|
let msg = FromCompositorMsg::LogEntry(top_level_id, thread_name, entry);
|
|
let chan = self.constellation_chan.lock();
|
|
let _ = chan.send(msg);
|
|
}
|
|
}
|
|
|
|
fn flush(&self) {}
|
|
}
|
|
|
|
/// Rust uses `Record` for storing logging, but servo converts that to
|
|
/// a `LogEntry`. We do this so that we can record panics as well as log
|
|
/// messages, and because `Record` does not implement serde (de)serialization,
|
|
/// so cannot be used over an IPC channel.
|
|
fn log_entry(record: &Record) -> Option<LogEntry> {
|
|
match record.level() {
|
|
Level::Error if thread::panicking() => Some(LogEntry::Panic(
|
|
format!("{}", record.args()),
|
|
format!("{:?}", Backtrace::new()),
|
|
)),
|
|
Level::Error => Some(LogEntry::Error(format!("{}", record.args()))),
|
|
Level::Warn => Some(LogEntry::Warn(format!("{}", record.args()))),
|
|
_ => None,
|
|
}
|
|
}
|